From fcbd052bf4d3708aad099643b17c289fe3419bc7 Mon Sep 17 00:00:00 2001 From: aboyko Date: Wed, 10 Jul 2024 09:43:17 -0400 Subject: [PATCH] PostgreSQL syntax highlighting and validation --- headless-services/commons/jpql/.gitignore | 4 + .../commons/jpql/generate-parsers.sh | 1 + .../commons/jpql/grammars/PostgreSqlLexer.g4 | 936 + .../commons/jpql/grammars/PostgreSqlParser.g4 | 1907 + .../parser/postgresql/PostgreSqlLexer.java | 6214 ++ .../parser/postgresql/PostgreSqlParser.java | 50547 ++++++++++++++++ .../PostgreSqlParserBaseListener.java | 3232 + .../postgresql/PostgreSqlParserListener.java | 2670 + .../data/jpa/queries/HqlSemanticTokens.java | 46 +- .../JdtDataQuerySemanticTokensProvider.java | 6 + .../data/jpa/queries/JpqlSemanticTokens.java | 49 +- .../data/jpa/queries/MySqlSemanticTokens.java | 104 +- .../jpa/queries/PostgreSqlSemanticTokens.java | 204 + .../jpa/queries/QueryJdtAstReconciler.java | 5 + .../boot/java/data/jpa/queries/SqlType.java | 3 +- .../jpa/queries/HqlSemanticTokensTest.java | 3 +- ...dtDataQuerySemanticTokensProviderTest.java | 34 +- .../jpa/queries/JpqlSemanticTokensTest.java | 3 +- .../jpa/queries/MySqlSemanticTokensTest.java | 22 +- .../queries/PostgreSqlSemanticTokensTest.java | 84 + .../data/jpa/queries/QueryReconcilerTest.java | 30 +- .../src/test/resources/.gitignore | 1 + .../{boot-sql => boot-mysql}/mvnw | 0 .../{boot-sql => boot-mysql}/mvnw.cmd | 0 .../{boot-sql => boot-mysql}/pom.xml | 0 .../test-projects/boot-postgresql/mvnw | 308 + .../test-projects/boot-postgresql/mvnw.cmd | 205 + .../test-projects/boot-postgresql/pom.xml | 48 + .../boot-sql/.mvn/wrapper/maven-wrapper.jar | Bin 62547 -> 0 bytes .../.mvn/wrapper/maven-wrapper.properties | 18 - 30 files changed, 66614 insertions(+), 70 deletions(-) create mode 100644 headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 create mode 100644 headless-services/commons/jpql/grammars/PostgreSqlParser.g4 create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBaseListener.java create mode 100644 headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserListener.java create mode 100644 headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokens.java create mode 100644 headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokensTest.java create mode 100644 headless-services/spring-boot-language-server/src/test/resources/.gitignore rename headless-services/spring-boot-language-server/src/test/resources/test-projects/{boot-sql => boot-mysql}/mvnw (100%) rename headless-services/spring-boot-language-server/src/test/resources/test-projects/{boot-sql => boot-mysql}/mvnw.cmd (100%) rename headless-services/spring-boot-language-server/src/test/resources/test-projects/{boot-sql => boot-mysql}/pom.xml (100%) create mode 100755 headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw create mode 100644 headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw.cmd create mode 100644 headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/pom.xml delete mode 100644 headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.jar delete mode 100644 headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.properties diff --git a/headless-services/commons/jpql/.gitignore b/headless-services/commons/jpql/.gitignore index 9ef1bc37d..d7812a664 100644 --- a/headless-services/commons/jpql/.gitignore +++ b/headless-services/commons/jpql/.gitignore @@ -11,6 +11,10 @@ /src/main/java/org/springframework/ide/vscode/parser/mysql/MySqlParser.tokens /src/main/java/org/springframework/ide/vscode/parser/mysql/MySqlLexer.interp /src/main/java/org/springframework/ide/vscode/parser/mysql/MySqlLexer.tokens +/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.interp +/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.tokens +/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.interp +/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.tokens /src/main/java/org/springframework/ide/vscode/parser/spel/SpelParser.interp /src/main/java/org/springframework/ide/vscode/parser/spel/SpelParser.tokens /src/main/java/org/springframework/ide/vscode/parser/spel/SpelLexer.interp diff --git a/headless-services/commons/jpql/generate-parsers.sh b/headless-services/commons/jpql/generate-parsers.sh index 68d72c86f..e44a3044b 100755 --- a/headless-services/commons/jpql/generate-parsers.sh +++ b/headless-services/commons/jpql/generate-parsers.sh @@ -10,4 +10,5 @@ java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar Jpql.g4 -o ${workdir}/src/main/j java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar Hql.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/hql -package org.springframework.ide.vscode.parser.hql java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar MySqlLexer.g4 MySqlParser.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/mysql -package org.springframework.ide.vscode.parser.mysql java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar SpelLexer.g4 SpelParser.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/spel -package org.springframework.ide.vscode.parser.spel +java -jar ${workdir}/antlr-${ANTLR_VERSION}.jar PostgreSqlLexer.g4 PostgreSqlParser.g4 -o ${workdir}/src/main/java/org/springframework/ide/vscode/parser/postgresql -package org.springframework.ide.vscode.parser.postgresql diff --git a/headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 b/headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 new file mode 100644 index 000000000..0cd59cc63 --- /dev/null +++ b/headless-services/commons/jpql/grammars/PostgreSqlLexer.g4 @@ -0,0 +1,936 @@ +// The MIT License + +// 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. + +lexer grammar PostgreSqlLexer; + +// Skip +WHITESPACE : [ \t\r\n]+ -> skip; +BLOCK_COMMENT : '/*' .*? '*/' -> channel(HIDDEN); +LINE_COMMENT : '--' .*? '\n' -> channel(HIDDEN); + +// 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') ; + +fragment HEX_DIGIT : [0-9A-F]; +fragment DEC_DIGIT : [0-9]; +fragment DQUOTA_STRING : '"' ( '\\'. | '""' | ~('"' | '\\') )* '"'; +fragment SQUOTA_STRING : '\'' ('\\'. | '\'\'' | ~('\'' | '\\'))* '\''; +fragment BQUOTA_STRING : '`' ( '\\'. | '``' | ~('`' | '\\'))* '`'; + +// 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_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; + +// 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; + +// create collation +IF : I F; + +// 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; + +// 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 ; + +// create event +EVENT : E V E N T; + +// create foreign data wrapper +WRAPPER : W R A P P E R; + +// create foreign table +SERVER : S E R V E R; + +// 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; + +// create language +INLINE : I N L I N E; + +// create materialized view +MATERIALIZED : M A T E R I A L I Z E D; + +// 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; + +// create operator family +FAMILY : F A M I L Y; + +// create policy +POLICY : P O L I C Y; + +// create sequence +OWNED : O W N E D; + +// 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; + +// 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$]*; + +// 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: ';'; + +SPEL : '#{' ANYTHING '}'; +fragment ANYTHING : (.)*?; + diff --git a/headless-services/commons/jpql/grammars/PostgreSqlParser.g4 b/headless-services/commons/jpql/grammars/PostgreSqlParser.g4 new file mode 100644 index 000000000..f291e1e5f --- /dev/null +++ b/headless-services/commons/jpql/grammars/PostgreSqlParser.g4 @@ -0,0 +1,1907 @@ +// The MIT License + +// 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. + +parser grammar PostgreSqlParser; + +options { tokenVocab=PostgreSqlLexer; } + + +root + : stmt ((SEMI stmt)+ SEMI)? EOF + ; + +// 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) + ; + +abort_stmt + : identifier + ; + +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 + ; + +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 + ; + +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 + ; + +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 + ; + +alter_database_stmt + : todo_implement + ; + +alter_default_privileges_stmt + : todo_implement + ; + +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 + ; + +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 + ; + +alter_extension_stmt + : ALTER EXTENSION name=identifier UPDATE (TO new_version=identifier)? + | ALTER EXTENSION name=identifier SET SCHEMA new_schema=identifier + ; + +alter_foreign_data_wrapper_stmt + : todo_implement + ; + +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 + | SET WITHOUT OIDS + | INHERIT parent_table=identifier + | NO INHERIT parent_table=identifier + | OWNER TO new_owner=role_name + | OPTIONS ((ADD|SET|DROP)?) + ; + +alter_foreign_table_action_list + : alter_foreign_table_action (COMMA alter_foreign_table_action)* + ; + +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 + ; + +alter_function_stmt + : todo_implement + ; + +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_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? + ; + +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) + ; + +alter_large_object_stmt + : ALTER LARGE OBJECT large_object_oid=INTEGER_LITERAL OWNER TO (new_owner=identifier|CURRENT_USER|SESSION_USER) + ; + +alter_materialize_view_stmt + : todo_implement + ; + +alter_operator_stmt + : todo_implement + ; + +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_operator_family_stmt + : todo_implement + ; + +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)? + ; + +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_ + ; + +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 + ; + +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 + ; + +alter_rule_stmt + : ALTER RULE name=name_ ON table_name=identifier RENAME TO new_name=name_ + ; + +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_sequence_stmt + : ALTER SEQUENCE (IF EXISTS)? name=name_ + ; + +alter_server_options_list + : ((ADD|SET|DROP)? option=identifier (value=param_value)?) + (COMMA (ADD|SET|DROP)? option=identifier (value=param_value)?)* + ; + +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_ + ; + +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 + ; + +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 + ; + +alter_system_stmt + : ALTER SYSTEM SET param=IDENTIFIER (TO|EQUAL) value=param_value + | ALTER SYSTEM RESET param=IDENTIFIER + | ALTER SYSTEM RESET ALL + ; + +alter_table_stmt + : todo_implement + ; + +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 + ; + +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 + ; + +alter_text_search_dict_stmt + : todo_implement + ; + +alter_text_search_parser_stmt + : todo_implement + ; + +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 + ; + +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 + ; + +alter_type_stmt + : todo_implement + ; + +alter_user_stmt + : todo_implement + ; + +alter_user_mapping_stmt + : ALTER USER MAPPING FOR user=role_name + SERVER server_name=identifier + OPTIONS (OPEN_PAREN alter_server_options_list CLOSE_PAREN) + ; + +alter_view_stmt + : todo_implement + ; + +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 INTEGER_LITERAL)? + (IS_TEMPLATE EQUAL INTEGER_LITERAL)? + ) + ; + +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 INTEGER_LITERAL | 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)+)? + ; + +create_rule_event + : SELECT | INSERT | UPDATE | DELETE + ; + +// 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) + ; + +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) + ; + +create_sequence_stmt + : CREATE (TEMPORARY | TEMP)? SEQUENCE (IF NOT EXISTS)? name=identifier (INCREMENT BY? increment=INTEGER_LITERAL)? + (MINVALUE minvalue=INTEGER_LITERAL | NO MINVALUE)? + (MAXVALUE maxvalue=INTEGER_LITERAL | NO MAXVALUE)? + (START WITH? start=INTEGER_LITERAL)? (CACHE cache=INTEGER_LITERAL)? (NO? CYCLE)? + (OWNED BY ((table_name=identifier DOT column_name_=identifier) | NONE))? + ; + +create_server_stmt + : todo_implement + ; + +create_statistics_stmt + : todo_implement + ; + +create_subscription_stmt + : todo_implement + ; + +create_table_stmt + : todo_implement + ; + +create_table_as_stmt + : todo_implement + ; + +create_tablespace_stmt + : todo_implement + ; + +create_text_search_config_stmt + : todo_implement + ; + +create_text_search_dict_stmt + : todo_implement + ; + +create_text_search_parser_stmt + : todo_implement + ; + +create_text_search_template_stmt + : todo_implement + ; + +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)? + ; + +drop_aggregate_stmt + : DROP AGGREGATE (IF EXISTS)? name=identifier OPEN_PAREN aggregate_signature CLOSE_PAREN + ; + +drop_cast_stmt + : DROP CAST (IF EXISTS)? OPEN_PAREN source_type=data_type AS target_type=identifier CLOSE_PAREN (CASCADE|RESTRICT)? + ; + +drop_collation_stmt + : DROP COLLATION (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_conversion_stmt + : DROP CONVERSION (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_database_stmt + : DROP DATABASE (IF EXISTS)? name=identifier + ; + +drop_domain_stmt + : DROP DOMAIN (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_event_trigger_stmt + : DROP EVENT TRIGGER (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_extension_stmt + : DROP EXTENSION (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_foreign_data_wrapper_stmt + : DROP FOREIGN DATA WRAPPER (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_foreign_table_stmt + : DROP FOREIGN TABLE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_function_stmt + : DROP FUNCTION (IF EXISTS)? functions=func_sig_list (CASCADE|RESTRICT)? + ; + +drop_group_stmt + : DROP GROUP (IF EXISTS)? names=identifier_list + ; + +drop_index_stmt + : DROP INDEX CONCURRENTLY? (IF EXISTS)? names=name_list (CASCADE|RESTRICT)? + ; + +drop_language_stmt + : DROP PROCEDURAL? LANGUAGE (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_materialized_view_stmt + : DROP MATERIALIZED VIEW (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_operator_stmt + : todo_implement + ; + +drop_operator_class_stmt + : DROP OPERATOR CLASS (IF EXISTS)? name=identifier USING index_method (CASCADE|RESTRICT)? + ; + +drop_operator_family_stmt + : DROP OPERATOR FAMILY (IF EXISTS)? name=identifier USING index_method (CASCADE|RESTRICT)? + ; + +drop_owned_stmt + : DROP OWNED BY role_name_list (CASCADE|RESTRICT)? + ; + +drop_policy_stmt + : DROP POLICY (IF EXISTS)? name=identifier ON table_name=identifier (CASCADE|RESTRICT)? + ; + +drop_publication_stmt + : DROP PUBLICATION (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_role_stmt + : DROP ROLE (IF EXISTS)? names=identifier_list + ; + +drop_rule_stmt + : DROP RULE (IF EXISTS)? name=name_ ON table_name=identifier (CASCADE|RESTRICT)? + ; + +drop_schema_stmt + : DROP SCHEMA (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_sequence_stmt + : DROP SEQUENCE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_server_stmt + : DROP SERVER (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_statistics_stmt + : DROP STATISTICS (IF EXISTS)? names=identifier_list + ; + +drop_subscription_stmt + : DROP SUBSCRIPTION (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_table_stmt + : DROP TABLE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_tablespace_stmt + : DROP TABLESPACE (IF EXISTS)? name=identifier + ; + +drop_text_search_config_stmt + : DROP TEXT SEARCH CONFIGURATION (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_text_search_dict_stmt + : DROP TEXT SEARCH DICTIONARY (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_text_search_parser_stmt + : DROP TEXT SEARCH PARSER (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_text_search_template_stmt + : DROP TEXT SEARCH TEMPLATE (IF EXISTS)? name=identifier (CASCADE|RESTRICT)? + ; + +drop_transform_stmt + : DROP TRANSFORM (IF EXISTS)? FOR type_name_=identifier LANGUAGE lang_name=identifier (CASCADE|RESTRICT) + ; + +drop_trigger_stmt + : DROP TRIGGER (IF EXISTS)? name=identifier ON table_name=identifier (CASCADE|RESTRICT)? + ; + +drop_type_stmt + : DROP TYPE (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +drop_user_stmt + : DROP USER (IF EXISTS)? names=identifier_list + ; + +drop_user_mapping_stmt + : DROP USER MAPPING (IF EXISTS)? FOR (user_name=name_|USER|CURRENT_USER|SESSION_USER|PUBLIC) SERVER server_name=identifier + ; + +drop_view_stmt + : DROP VIEW (IF EXISTS)? names=identifier_list (CASCADE|RESTRICT)? + ; + +execute_stmt + : EXECUTE name=identifier expr_list? + ; + +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) + ; + +fetch_stmt + : todo_implement + ; + +grant_stmt + : todo_implement + ; + +import_foreign_schema_stmt + : todo_implement + ; + +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?)) + )? + returning_clause? + ; + +listen_stmt + : LISTEN channel=identifier + ; + +load_stmt + : todo_implement + ; + +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? + ; + +move_stmt + : MOVE ((NEXT | PRIOR | FIRST | LAST | ABSOLUTE INTEGER | RELATIVE INTEGER_LITERAL | INTEGER_LITERAL | + ALL | FORWARD (INTEGER_LITERAL|ALL)? | BACKWARD (INTEGER_LITERAL|ALL)?) (FROM|IN)?)? cursor_name=name_ + ; + +notify_stmt + : NOTIFY channel=name_ (COMMA payload=SINGLEQ_STRING_LITERAL)? + ; + +prepare_stmt + : PREPARE name=identifier (OPEN_PAREN data_type_list CLOSE_PAREN)? AS + (select_stmt|insert_stmt|update_stmt|delete_stmt|values_stmt) + ; + +prepare_transaction_stmt + : PREPARE TRANSACTION name=name_ + ; + +reassign_owned_stmt + : REASSIGN OWNED + BY ((identifier|CURRENT_USER|SESSION_USER) (COMMA (identifier|CURRENT_USER|SESSION_USER))*) + TO (identifier|CURRENT_USER|SESSION_USER) + ; + +refresh_materialized_view_stmt + : todo_implement + ; + +reindex_stmt + : REINDEX (OPEN_PAREN VERBOSE CLOSE_PAREN)? (INDEX | TABLE | SCHEMA | DATABASE | SYSTEM) name=identifier + ; + +release_savepoint_stmt + : RELEASE SAVEPOINT? savepoint_name=identifier + ; + +reset_stmt + : RESET (configuration_parameter=identifier | ALL) + ; + +revoke_stmt + : todo_implement + ; + +rollback_stmt + : ROLLBACK (WORK | TRANSACTION)? + ; + +rollback_prepared_stmt + : ROLLBACK PREPARED transaction_id=INTEGER_LITERAL + ; + +rollback_to_savepoint_stmt + : ROLLBACK (WORK | TRANSACTION)? TO SAVEPOINT? savepoint_name=identifier + ; + +savepoint_stmt + : SAVEPOINT savepoint_name=identifier + ; + +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 + ; + +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? + ; + +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? + ; + +with_clause: + WITH RECURSIVE? with_expr (COMMA with_expr)* + ; + +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 + ; + +set_stmt + : SET (SESSION | LOCAL)? configuration_parameter=identifier (TO | EQUAL) (value=param_value | DEFAULT) + | SET (SESSION | LOCAL)? TIME ZONE (timezone | LOCAL | DEFAULT) + ; + +set_constraints_stmt + : SET CONSTRAINTS (ALL | constraints=identifier_list) (DEFERRED | IMMEDIATE) + ; + +set_role_stmt + : SET (SESSION | LOCAL)? ROLE (role_name_=role_name | NONE) + | RESET ROLE + ; + +set_session_authorization_stmt + : todo_implement + ; + +transaction_mode + : ISOLATION LEVEL (SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED) + | READ WRITE + | READ ONLY + | NOT? DEFERRABLE + ; + +transaction_mode_list + : transaction_mode (COMMA transaction_mode)* + ; + +set_transaction_stmt + : SET TRANSACTION transaction_mode_list + | SET TRANSACTION SNAPSHOT snapshot_id=SINGLEQ_STRING_LITERAL + | SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list + ; + +show_stmt + : SHOW (name=identifier | TIME ZONE | ALL) + ; + +truncate_stmt + : TRUNCATE TABLE? ONLY? table_name_ STAR? (COMMA ONLY? identifier_list)? + ((RESTART | CONTINUE) IDENTITY)? (CASCADE | RESTRICT)? + ; + +unlisten_stmt + : UNLISTEN (channel=identifier | STAR) + ; + +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? + ; + +vacuum_opt + : FULL | FREEZE | VERBOSE | ANALYZE | DISABLE_PAGE_SKIPPING + ; + +vacuum_opt_list + : vacuum_opt (COMMA vacuum_opt)* + ; + +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)?)? + ; + +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? + ; + +selector_clause + :(ALL | (DISTINCT (ON expr_list)?))? column_list + ; + +from_clause + : FROM from_item (COMMA from_item)* + ; + +where_clause + : WHERE predicate + ; + +group_by_clause + : GROUP BY grouping_elem (COMMA grouping_elem)* + ; + +grouping_elem + : 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 + ; + +having_clause + : HAVING predicate (COMMA predicate)* + ; + +column_list + : ((column_name_=expr (AS? output_name=name_)?) | STAR) + (COMMA ((column_name_=expr (AS? output_name=name_)?) | STAR))* + ; + +explain_parameter + : (ANALYZE | VERBOSE | COSTS | BUFFERS | TIMING) param_value? + | FORMAT (TEXT | XML | JSON | YAML) + ; + +frame + : UNBOUNDED PRECEDING + | INTEGER_LITERAL PRECEDING + | CURRENT ROW + | INTEGER_LITERAL FOLLOWING + | UNBOUNDED FOLLOWING + ; + +frame_start + : frame + ; + +frame_end + : frame + ; + +frame_clause + : (RANGE | ROWS) frame_start + | (RANGE | ROWS) BETWEEN frame_start AND frame_end + ; + +window_definition + : window_name + | PARTITION BY expr (COMMA expr)* + | order_by_clause + ; + +window_clause + : WINDOW window_name AS OPEN_PAREN window_definition CLOSE_PAREN + ; + +combine_clause + : ( UNION | INTERSECT | EXCEPT ) ( ALL | DISTINCT)? OPEN_PAREN* (select_stmt | values_stmt) CLOSE_PAREN* combine_clause? + ; + +order_by_clause + : ORDER BY order_by_item (COMMA order_by_item)* + ; + +order_by_item + : (expr | DOUBLEQ_STRING_LITERAL) (ASC | DESC | USING expr)? ( (NULLS (FIRST | LAST)) (COMMA (NULLS (FIRST | LAST)))*)? + ; + +limit_clause + : LIMIT (INTEGER_LITERAL | ALL | func_call) + ; + +offset_clause + : OFFSET INTEGER_LITERAL (ROW | ROWS)? + ; + +fetch_clause + : FETCH (FIRST | NEXT) INTEGER_LITERAL? (ROW | ROWS) ONLY + ; + +for_clause + : FOR ( UPDATE | NO KEY UPDATE | SHARE | KEY SHARE ) (OF table_name_ (COMMA table_name_)*)? ( NOWAIT | SKIP_ LOCKED)* + ; + +updater_clause + : updater_expr (COMMA updater_expr)* + ; + +updater_expr + : expr + | (OPEN_PAREN name_list CLOSE_PAREN EQUAL (expr | expr_list)) + ; + +returning_clause + : RETURNING column_list + ; + +// TODO: split into more granular expression types? +// TODO: handle operators like BETWEEN in a more normalized way +expr + : NULL + | 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 + | 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 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 + | 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 + ; + +parameter + : prefix=':' SPEL + | prefix=':' identifier + | prefix='?' SPEL + | prefix='?' INTEGER_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 + | NUMERIC_LITERAL + | INTEGER_LITERAL + | identifier + ; + +// 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_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 | 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/PostgreSqlLexer.java b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java new file mode 100644 index 000000000..c0e52f0a5 --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlLexer.java @@ -0,0 +1,6214 @@ +// 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; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +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 { + 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_LEVEL_COUNT=585, TRAILING=586, TRANSACTION=587, TRANSACTION_ACTIVE=588, + TRANSACTIONS_COMMITTED=589, TRANSACTIONS_ROLLED_BACK=590, TRANSFORM=591, + TRANSFORMS=592, TRANSLATE=593, TRANSLATION=594, TREAT=595, TRIGGER=596, + TRIGGER_CATALOG=597, TRIGGER_NAME=598, TRIGGER_SCHEMA=599, TRIM=600, TRUE=601, + TRUNCATE=602, TRUSTED=603, TYPE=604, UESCAPE=605, UNBOUNDED=606, UNCOMMITTED=607, + UNDER=608, UNENCRYPTED=609, UNION=610, UNIQUE=611, UNKNOWN=612, UNLISTEN=613, + UNLOGGED=614, UNNAMED=615, UNNEST=616, UNTIL=617, UPDATE=618, UPPER=619, + USAGE=620, USER=621, USER_DEFINED_TYPE_CATALOG=622, USER_DEFINED_TYPE_CODE=623, + USER_DEFINED_TYPE_NAME=624, USER_DEFINED_TYPE_SCHEMA=625, USING=626, VACUUM=627, + VALID=628, VALIDATE=629, VALIDATOR=630, VALUE=631, VALUES=632, VAR_POP=633, + VAR_SAMP=634, VARCHAR=635, VARIABLE=636, VARIADIC=637, VARYING=638, VERBOSE=639, + VIEW=640, VOLATILE=641, WHEN=642, WHENEVER=643, WHERE=644, WIDTH_BUCKET=645, + WINDOW=646, WITH=647, WITHIN=648, WITHOUT=649, WORK=650, WRITE=651, YAML=652, + YEAR=653, YES=654, ZONE=655, SUPERUSER=656, NOSUPERUSER=657, CREATEROLE=658, + NOCREATEROLE=659, INHERIT=660, NOINHERIT=661, LOGIN=662, NOLOGIN=663, + REPLICATION=664, NOREPLICATION=665, BYPASSRLS=666, NOBYPASSRLS=667, SFUNC=668, + STYPE=669, SSPACE=670, FINALFUNC=671, FINALFUNC_EXTRA=672, COMBINEFUNC=673, + SERIALFUNC=674, DESERIALFUNC=675, INITCOND=676, MSFUNC=677, MINVFUNC=678, + MSTYPE=679, MSSPACE=680, MFINALFUNC=681, MFINALFUNC_EXTRA=682, MINITCOND=683, + SORTOP=684, PARALLEL=685, HYPOTHETICAL=686, SAFE=687, RESTRICTED=688, + UNSAFE=689, BASETYPE=690, IF=691, LOCALE=692, LC_COLLATE=693, LC_CTYPE=694, + PROVIDER=695, VERSION=696, ALLOW_CONNECTIONS=697, IS_TEMPLATE=698, EVENT=699, + WRAPPER=700, SERVER=701, BTREE=702, HASH_=703, GIST=704, SPGIST=705, GIN=706, + BRIN=707, CONCURRENTLY=708, INLINE=709, MATERIALIZED=710, LEFTARG=711, + RIGHTARG=712, COMMUTATOR=713, NEGATOR=714, HASHES=715, MERGES=716, FAMILY=717, + POLICY=718, OWNED=719, ABSTIME=720, BIGSERIAL=721, BIT_VARYING=722, BOOL=723, + BOX=724, BYTEA=725, CHARACTER_VARYING=726, CIDR=727, CIRCLE=728, FLOAT4=729, + FLOAT8=730, INET=731, INT2=732, INT4=733, INT8=734, JSON=735, JSONB=736, + LINE=737, LSEG=738, MACADDR=739, MACADDR8=740, MONEY=741, PG_LSN=742, + POINT=743, POLYGON=744, RELTIME=745, SERIAL=746, SERIAL2=747, SERIAL4=748, + SERIAL8=749, SMALLSERIAL=750, STSTEM=751, TEXT=752, TIMESTAMPTZ=753, TIMETZ=754, + TSQUERY=755, TSVECTOR=756, TXID_SNAPSHOT=757, UUID=758, VARBIT=759, XML=760, + COMMA=761, COLON=762, COLON_COLON=763, DOLLAR=764, DOLLAR_DOLLAR=765, + STAR=766, OPEN_PAREN=767, CLOSE_PAREN=768, OPEN_BRACKET=769, CLOSE_BRACKET=770, + BIT_STRING=771, REGEX_STRING=772, NUMERIC_LITERAL=773, INTEGER_LITERAL=774, + HEX_INTEGER_LITERAL=775, DOT=776, SINGLEQ_STRING_LITERAL=777, DOUBLEQ_STRING_LITERAL=778, + IDENTIFIER=779, DOLLAR_DEC=780, IDENTIFIER_UNICODE=781, AMP=782, AMP_AMP=783, + AMP_LT=784, AT_AT=785, AT_GT=786, AT_SIGN=787, BANG=788, BANG_BANG=789, + BANG_EQUAL=790, CARET=791, EQUAL=792, EQUAL_GT=793, GT=794, GTE=795, GT_GT=796, + HASH=797, HASH_EQ=798, HASH_GT=799, HASH_GT_GT=800, HASH_HASH=801, HYPHEN_GT=802, + HYPHEN_GT_GT=803, HYPHEN_PIPE_HYPHEN=804, LT=805, LTE=806, LT_AT=807, + LT_CARET=808, LT_GT=809, LT_HYPHEN_GT=810, LT_LT=811, LT_LT_EQ=812, LT_QMARK_GT=813, + MINUS=814, PERCENT=815, PIPE=816, PIPE_PIPE=817, PIPE_PIPE_SLASH=818, + PIPE_SLASH=819, PLUS=820, QMARK=821, QMARK_AMP=822, QMARK_HASH=823, QMARK_HYPHEN=824, + QMARK_PIPE=825, SLASH=826, TIL=827, TIL_EQ=828, TIL_GTE_TIL=829, TIL_GT_TIL=830, + TIL_LTE_TIL=831, TIL_LT_TIL=832, TIL_STAR=833, TIL_TIL=834, SEMI=835, + SPEL=836; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + 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_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" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, 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_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" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public PostgreSqlLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "PostgreSqlLexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + private static final String _serializedATNSegment0 = + "\u0004\u0000\u0344\u2200\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"+ + "\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e"+ + "\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011"+ + "\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014"+ + "\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017"+ + "\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a"+ + "\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d"+ + "\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!"+ + "\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002"+ + "&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002"+ + "+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u0002"+ + "0\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u0002"+ + "5\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002"+ + ":\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002"+ + "?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002"+ + "D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002"+ + "I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002"+ + "N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002"+ + "S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002"+ + "X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002"+ + "]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002"+ + "b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002"+ + "g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002"+ + "l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002"+ + "q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002"+ + "v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002"+ + "{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f"+ + "\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082"+ + "\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085"+ + "\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088"+ + "\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b"+ + "\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e"+ + "\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091"+ + "\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094"+ + "\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097"+ + "\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a"+ + "\u0002\u009b\u0007\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d"+ + "\u0002\u009e\u0007\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0"+ + "\u0002\u00a1\u0007\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3"+ + "\u0002\u00a4\u0007\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6"+ + "\u0002\u00a7\u0007\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9"+ + "\u0002\u00aa\u0007\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac"+ + "\u0002\u00ad\u0007\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af"+ + "\u0002\u00b0\u0007\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2"+ + "\u0002\u00b3\u0007\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5"+ + "\u0002\u00b6\u0007\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8"+ + "\u0002\u00b9\u0007\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb"+ + "\u0002\u00bc\u0007\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be"+ + "\u0002\u00bf\u0007\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1"+ + "\u0002\u00c2\u0007\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4"+ + "\u0002\u00c5\u0007\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7"+ + "\u0002\u00c8\u0007\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca"+ + "\u0002\u00cb\u0007\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd"+ + "\u0002\u00ce\u0007\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0"+ + "\u0002\u00d1\u0007\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3"+ + "\u0002\u00d4\u0007\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6"+ + "\u0002\u00d7\u0007\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9"+ + "\u0002\u00da\u0007\u00da\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc"+ + "\u0002\u00dd\u0007\u00dd\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df"+ + "\u0002\u00e0\u0007\u00e0\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2"+ + "\u0002\u00e3\u0007\u00e3\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5"+ + "\u0002\u00e6\u0007\u00e6\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8"+ + "\u0002\u00e9\u0007\u00e9\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb"+ + "\u0002\u00ec\u0007\u00ec\u0002\u00ed\u0007\u00ed\u0002\u00ee\u0007\u00ee"+ + "\u0002\u00ef\u0007\u00ef\u0002\u00f0\u0007\u00f0\u0002\u00f1\u0007\u00f1"+ + "\u0002\u00f2\u0007\u00f2\u0002\u00f3\u0007\u00f3\u0002\u00f4\u0007\u00f4"+ + "\u0002\u00f5\u0007\u00f5\u0002\u00f6\u0007\u00f6\u0002\u00f7\u0007\u00f7"+ + "\u0002\u00f8\u0007\u00f8\u0002\u00f9\u0007\u00f9\u0002\u00fa\u0007\u00fa"+ + "\u0002\u00fb\u0007\u00fb\u0002\u00fc\u0007\u00fc\u0002\u00fd\u0007\u00fd"+ + "\u0002\u00fe\u0007\u00fe\u0002\u00ff\u0007\u00ff\u0002\u0100\u0007\u0100"+ + "\u0002\u0101\u0007\u0101\u0002\u0102\u0007\u0102\u0002\u0103\u0007\u0103"+ + "\u0002\u0104\u0007\u0104\u0002\u0105\u0007\u0105\u0002\u0106\u0007\u0106"+ + "\u0002\u0107\u0007\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\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\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\u0001\u0000\u0004\u0000"+ + "\u06cb\b\u0000\u000b\u0000\f\u0000\u06cc\u0001\u0000\u0001\u0000\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0005\u0001\u06d5\b\u0001\n"+ + "\u0001\f\u0001\u06d8\t\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0005"+ + "\u0002\u06e3\b\u0002\n\u0002\f\u0002\u06e6\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\u072a\b\u001f\n\u001f\f\u001f\u072d\t\u001f\u0001\u001f"+ + "\u0001\u001f\u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0005 \u0737\b"+ + " \n \f \u073a\t \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+ + "!\u0005!\u0744\b!\n!\f!\u0747\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\u00011\u0001"+ + "1\u00011\u00011\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+ + "3\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u00014\u00014\u0001"+ + "4\u00014\u00014\u00014\u00014\u00014\u00015\u00015\u00015\u00015\u0001"+ + "6\u00016\u00016\u00016\u00017\u00017\u00017\u00017\u00018\u00018\u0001"+ + "8\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=\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\u0001"+ + "A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001"+ + "B\u0001B\u0001B\u0001B\u0001B\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+ + "C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001D\u0001"+ + "D\u0001D\u0001D\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001"+ + "E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001G\u0001"+ + "G\u0001G\u0001G\u0001G\u0001G\u0001H\u0001H\u0001H\u0001H\u0001H\u0001"+ + "H\u0001H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001I\u0001"+ + "I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001J\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0001"+ + "L\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001"+ + "M\u0001M\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001"+ + "O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001P\u0001"+ + "P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001"+ + "R\u0001R\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001U\u0001U\u0001V\u0001V\u0001"+ + "V\u0001V\u0001V\u0001V\u0001W\u0001W\u0001W\u0001W\u0001W\u0001X\u0001"+ + "X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Z\u0001Z\u0001"+ + "Z\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\u0267\u0001\u0267\u0001\u0267\u0001\u0267\u0001\u0267\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\u0268\u0001\u0268\u0001\u0269\u0001\u0269\u0001\u0269"+ + "\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\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\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\u026c\u0001\u026c\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\u026e\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\u0270\u0001\u0270\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\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\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\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\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\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\u027b"+ + "\u0001\u027b\u0001\u027b\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\u027c\u0001\u027c\u0001\u027d"+ + "\u0001\u027d\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\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\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\u0283\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\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\u0288"+ + "\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\u028a\u0001\u028a\u0001\u028a\u0001\u028a\u0001\u028a\u0001\u028a"+ + "\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028b\u0001\u028c"+ + "\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c"+ + "\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c"+ + "\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c\u0001\u028c"+ + "\u0001\u028c\u0001\u028c\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\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\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f\u0001\u028f"+ + "\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\u0291\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\u0293\u0001\u0293\u0001\u0293\u0001\u0294\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\u0296\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\u0297\u0001\u0298"+ + "\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\u029a\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\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\u029f\u0001\u029f\u0001\u029f\u0001\u029f\u0001\u029f"+ + "\u0001\u029f\u0001\u029f\u0001\u029f\u0001\u029f\u0001\u02a0\u0001\u02a0"+ + "\u0001\u02a0\u0001\u02a0\u0001\u02a0\u0001\u02a1\u0001\u02a1\u0001\u02a1"+ + "\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1\u0001\u02a1"+ + "\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\u02a3\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\u02a5\u0001\u02a5\u0001\u02a5\u0001\u02a5"+ + "\u0001\u02a5\u0001\u02a6\u0001\u02a6\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\u02a7\u0001\u02a8\u0001\u02a8"+ + "\u0001\u02a8\u0001\u02a8\u0001\u02a8\u0001\u02a9\u0001\u02a9\u0001\u02a9"+ + "\u0001\u02a9\u0001\u02a9\u0001\u02a9\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\u02ad"+ + "\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ad\u0001\u02ae\u0001\u02ae"+ + "\u0001\u02ae\u0001\u02ae\u0001\u02ae\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\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\u02b1\u0001\u02b1\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\u02b3\u0001\u02b3"+ + "\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\u02b5\u0001\u02b5\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\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\u02b7\u0001\u02b7"+ + "\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\u02b9\u0001\u02b9\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\u02bc\u0001\u02bd"+ + "\u0001\u02bd\u0001\u02bd\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\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\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\u02c1"+ + "\u0001\u02c1\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\u02c4"+ + "\u0001\u02c4\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\u02c6\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\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\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\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\u02cb\u0001\u02cb\u0001\u02cc"+ + "\u0001\u02cc\u0001\u02cc\u0001\u02cc\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\u02ce"+ + "\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\u0001\u02ce\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\u02d0"+ + "\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001\u02d0\u0001\u02d0"+ + "\u0001\u02d0\u0001\u02d0\u0001\u02d1\u0001\u02d1\u0001\u02d1\u0001\u02d2"+ + "\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2\u0001\u02d2"+ + "\u0001\u02d3\u0001\u02d3\u0001\u02d3\u0001\u02d3\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\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\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\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\u02da\u0001\u02da\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\u02dc\u0001\u02dc"+ + "\u0001\u02dc\u0001\u02dc\u0001\u02dc\u0001\u02dc\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\u02df\u0001\u02df\u0001\u02e0\u0001\u02e0\u0001\u02e0"+ + "\u0001\u02e0\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1\u0001\u02e1"+ + "\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2\u0001\u02e2"+ + "\u0001\u02e2\u0001\u02e2\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\u02e4\u0001\u02e4\u0001\u02e4\u0001\u02e4"+ + "\u0001\u02e4\u0001\u02e4\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\u02e6"+ + "\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\u02e7"+ + "\u0001\u02e7\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\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\u02ee\u0001\u02ee\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\u02ef"+ + "\u0001\u02ef\u0001\u02f0\u0001\u02f0\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\u02f2\u0001\u02f2\u0001\u02f2\u0001\u02f2\u0001\u02f3\u0001\u02f3"+ + "\u0001\u02f3\u0001\u02f3\u0001\u02f3\u0001\u02f3\u0001\u02f4\u0001\u02f4"+ + "\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4"+ + "\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4"+ + "\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f4\u0001\u02f5\u0001\u02f5"+ + "\u0001\u02f5\u0001\u02f5\u0001\u02f5\u0001\u02f6\u0001\u02f6\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\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\u02fe\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\u0301\u0001\u0301"+ + "\u0001\u0301\u0001\u0302\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\u0304\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\u0306"+ + "\u0001\u0306\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\u0309\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\u030c\u0001\u030c\u0001\u030c\u0001\u030c\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\u030f\u0001\u030f"+ + "\u0001\u030f\u0001\u030f\u0001\u030f\u0001\u030f\u0001\u030f\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\u0311"+ + "\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\u0312\u0001\u0313\u0001\u0313"+ + "\u0001\u0313\u0001\u0313\u0001\u0313\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\u0315"+ + "\u0001\u0315\u0001\u0315\u0001\u0315\u0001\u0315\u0001\u0315\u0001\u0315"+ + "\u0001\u0316\u0001\u0316\u0001\u0316\u0001\u0316\u0001\u0317\u0001\u0317"+ + "\u0001\u0318\u0001\u0318\u0001\u0319\u0001\u0319\u0001\u0319\u0001\u031a"+ + "\u0001\u031a\u0001\u031b\u0001\u031b\u0001\u031b\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\u0321\u0005\u0321"+ + "\u2103\b\u0321\n\u0321\f\u0321\u2106\t\u0321\u0001\u0321\u0001\u0321\u0001"+ + "\u0322\u0001\u0322\u0001\u0322\u0001\u0323\u0003\u0323\u210e\b\u0323\u0001"+ + "\u0323\u0004\u0323\u2111\b\u0323\u000b\u0323\f\u0323\u2112\u0001\u0323"+ + "\u0001\u0323\u0004\u0323\u2117\b\u0323\u000b\u0323\f\u0323\u2118\u0001"+ + "\u0323\u0001\u0323\u0005\u0323\u211d\b\u0323\n\u0323\f\u0323\u2120\t\u0323"+ + "\u0001\u0323\u0004\u0323\u2123\b\u0323\u000b\u0323\f\u0323\u2124\u0003"+ + "\u0323\u2127\b\u0323\u0001\u0324\u0003\u0324\u212a\b\u0324\u0001\u0324"+ + "\u0004\u0324\u212d\b\u0324\u000b\u0324\f\u0324\u212e\u0001\u0324\u0001"+ + "\u0324\u0004\u0324\u2133\b\u0324\u000b\u0324\f\u0324\u2134\u0003\u0324"+ + "\u2137\b\u0324\u0001\u0325\u0001\u0325\u0001\u0325\u0001\u0326\u0001\u0326"+ + "\u0001\u0327\u0001\u0327\u0001\u0328\u0001\u0328\u0001\u0329\u0001\u0329"+ + "\u0005\u0329\u2144\b\u0329\n\u0329\f\u0329\u2147\t\u0329\u0001\u032a\u0001"+ + "\u032a\u0004\u032a\u214b\b\u032a\u000b\u032a\f\u032a\u214c\u0001\u032b"+ + "\u0001\u032b\u0005\u032b\u2151\b\u032b\n\u032b\f\u032b\u2154\t\u032b\u0001"+ + "\u032c\u0001\u032c\u0001\u032d\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\u0332\u0001\u0332\u0001"+ + "\u0333\u0001\u0333\u0001\u0333\u0001\u0334\u0001\u0334\u0001\u0334\u0001"+ + "\u0335\u0001\u0335\u0001\u0336\u0001\u0336\u0001\u0337\u0001\u0337\u0001"+ + "\u0337\u0001\u0338\u0001\u0338\u0001\u0339\u0001\u0339\u0001\u0339\u0001"+ + "\u033a\u0001\u033a\u0001\u033a\u0001\u033b\u0001\u033b\u0001\u033c\u0001"+ + "\u033c\u0001\u033c\u0001\u033d\u0001\u033d\u0001\u033d\u0001\u033e\u0001"+ + "\u033e\u0001\u033e\u0001\u033e\u0001\u033f\u0001\u033f\u0001\u033f\u0001"+ + "\u0340\u0001\u0340\u0001\u0340\u0001\u0341\u0001\u0341\u0001\u0341\u0001"+ + "\u0341\u0001\u0342\u0001\u0342\u0001\u0342\u0001\u0342\u0001\u0343\u0001"+ + "\u0343\u0001\u0344\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\u0348\u0001\u0349\u0001"+ + "\u0349\u0001\u0349\u0001\u034a\u0001\u034a\u0001\u034a\u0001\u034a\u0001"+ + "\u034b\u0001\u034b\u0001\u034b\u0001\u034b\u0001\u034c\u0001\u034c\u0001"+ + "\u034d\u0001\u034d\u0001\u034e\u0001\u034e\u0001\u034f\u0001\u034f\u0001"+ + "\u034f\u0001\u0350\u0001\u0350\u0001\u0350\u0001\u0350\u0001\u0351\u0001"+ + "\u0351\u0001\u0351\u0001\u0352\u0001\u0352\u0001\u0353\u0001\u0353\u0001"+ + "\u0354\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\u0359\u0001\u0359\u0001\u035a\u0001\u035a\u0001"+ + "\u035a\u0001\u035b\u0001\u035b\u0001\u035b\u0001\u035b\u0001\u035b\u0001"+ + "\u035c\u0001\u035c\u0001\u035c\u0001\u035c\u0001\u035d\u0001\u035d\u0001"+ + "\u035d\u0001\u035d\u0001\u035d\u0001\u035e\u0001\u035e\u0001\u035e\u0001"+ + "\u035e\u0001\u035f\u0001\u035f\u0001\u035f\u0001\u0360\u0001\u0360\u0001"+ + "\u0360\u0001\u0361\u0001\u0361\u0001\u0362\u0001\u0362\u0001\u0362\u0001"+ + "\u0362\u0001\u0362\u0001\u0362\u0001\u0363\u0005\u0363\u21fc\b\u0363\n"+ + "\u0363\f\u0363\u21ff\t\u0363\u0003\u06d6\u06e4\u21fd\u0000\u0364\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\u00003\u00005\u00007\u00009\u0000;\u0000=\u0000"+ + "?\u0000A\u0000C\u0000E\u0004G\u0005I\u0006K\u0007M\bO\tQ\nS\u000bU\fW"+ + "\rY\u000e[\u000f]\u0010_\u0011a\u0012c\u0013e\u0014g\u0015i\u0016k\u0017"+ + "m\u0018o\u0019q\u001as\u001bu\u001cw\u001dy\u001e{\u001f} \u007f!\u0081"+ + "\"\u0083#\u0085$\u0087%\u0089&\u008b\'\u008d(\u008f)\u0091*\u0093+\u0095"+ + ",\u0097-\u0099.\u009b/\u009d0\u009f1\u00a12\u00a33\u00a54\u00a75\u00a9"+ + "6\u00ab7\u00ad8\u00af9\u00b1:\u00b3;\u00b5<\u00b7=\u00b9>\u00bb?\u00bd"+ + "@\u00bfA\u00c1B\u00c3C\u00c5D\u00c7E\u00c9F\u00cbG\u00cdH\u00cfI\u00d1"+ + "J\u00d3K\u00d5L\u00d7M\u00d9N\u00dbO\u00ddP\u00dfQ\u00e1R\u00e3S\u00e5"+ + "T\u00e7U\u00e9V\u00ebW\u00edX\u00efY\u00f1Z\u00f3[\u00f5\\\u00f7]\u00f9"+ + "^\u00fb_\u00fd`\u00ffa\u0101b\u0103c\u0105d\u0107e\u0109f\u010bg\u010d"+ + "h\u010fi\u0111j\u0113k\u0115l\u0117m\u0119n\u011bo\u011dp\u011fq\u0121"+ + "r\u0123s\u0125t\u0127u\u0129v\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\u0000\u0001\u0000$\u0003"+ + "\u0000\t\n\r\r \u0002\u0000AAaa\u0002\u0000BBbb\u0002\u0000CCcc\u0002"+ + "\u0000DDdd\u0002\u0000EEee\u0002\u0000FFff\u0002\u0000GGgg\u0002\u0000"+ + "HHhh\u0002\u0000IIii\u0002\u0000JJjj\u0002\u0000KKkk\u0002\u0000LLll\u0002"+ + "\u0000MMmm\u0002\u0000NNnn\u0002\u0000OOoo\u0002\u0000PPpp\u0002\u0000"+ + "QQqq\u0002\u0000RRrr\u0002\u0000SSss\u0002\u0000TTtt\u0002\u0000UUuu\u0002"+ + "\u0000VVvv\u0002\u0000WWww\u0002\u0000XXxx\u0002\u0000YYyy\u0002\u0000"+ + "ZZzz\u0002\u000009AF\u0001\u000009\u0002\u0000\"\"\\\\\u0002\u0000\'\'"+ + "\\\\\u0002\u0000\\\\``\u0003\u0000AZ__az\u0005\u0000$$09AZ__az\u0004\u0000"+ + "AZ__az\u00a1\u8000\uffff\u0006\u0000$$09AZ__az\u00a1\u8000\uffff\u21fa"+ + "\u0000\u0001\u0001\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000\u0000"+ + "\u0000\u0005\u0001\u0000\u0000\u0000\u0000E\u0001\u0000\u0000\u0000\u0000"+ + "G\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\u0000"+ + "U\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\u0000"+ + "c\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\u0000"+ + "q\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\u0001\u0000\u0000\u0000\u0000"+ + "\u035f\u0001\u0000\u0000\u0000\u0000\u0361\u0001\u0000"; + private static final String _serializedATNSegment1 = + "\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\u0001\u06ca\u0001\u0000\u0000\u0000\u0003\u06d0\u0001\u0000"+ + "\u0000\u0000\u0005\u06de\u0001\u0000\u0000\u0000\u0007\u06eb\u0001\u0000"+ + "\u0000\u0000\t\u06ed\u0001\u0000\u0000\u0000\u000b\u06ef\u0001\u0000\u0000"+ + "\u0000\r\u06f1\u0001\u0000\u0000\u0000\u000f\u06f3\u0001\u0000\u0000\u0000"+ + "\u0011\u06f5\u0001\u0000\u0000\u0000\u0013\u06f7\u0001\u0000\u0000\u0000"+ + "\u0015\u06f9\u0001\u0000\u0000\u0000\u0017\u06fb\u0001\u0000\u0000\u0000"+ + "\u0019\u06fd\u0001\u0000\u0000\u0000\u001b\u06ff\u0001\u0000\u0000\u0000"+ + "\u001d\u0701\u0001\u0000\u0000\u0000\u001f\u0703\u0001\u0000\u0000\u0000"+ + "!\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\u00001\u0715\u0001\u0000\u0000\u00003"+ + "\u0717\u0001\u0000\u0000\u00005\u0719\u0001\u0000\u0000\u00007\u071b\u0001"+ + "\u0000\u0000\u00009\u071d\u0001\u0000\u0000\u0000;\u071f\u0001\u0000\u0000"+ + "\u0000=\u0721\u0001\u0000\u0000\u0000?\u0723\u0001\u0000\u0000\u0000A"+ + "\u0730\u0001\u0000\u0000\u0000C\u073d\u0001\u0000\u0000\u0000E\u074a\u0001"+ + "\u0000\u0000\u0000G\u074c\u0001\u0000\u0000\u0000I\u0752\u0001\u0000\u0000"+ + "\u0000K\u0756\u0001\u0000\u0000\u0000M\u075f\u0001\u0000\u0000\u0000O"+ + "\u0766\u0001\u0000\u0000\u0000Q\u076d\u0001\u0000\u0000\u0000S\u0771\u0001"+ + "\u0000\u0000\u0000U\u0775\u0001\u0000\u0000\u0000W\u077b\u0001\u0000\u0000"+ + "\u0000Y\u0781\u0001\u0000\u0000\u0000[\u078b\u0001\u0000\u0000\u0000]"+ + "\u0791\u0001\u0000\u0000\u0000_\u0795\u0001\u0000\u0000\u0000a\u079e\u0001"+ + "\u0000\u0000\u0000c\u07a3\u0001\u0000\u0000\u0000e\u07a9\u0001\u0000\u0000"+ + "\u0000g\u07b0\u0001\u0000\u0000\u0000i\u07b8\u0001\u0000\u0000\u0000k"+ + "\u07c0\u0001\u0000\u0000\u0000m\u07c4\u0001\u0000\u0000\u0000o\u07c8\u0001"+ + "\u0000\u0000\u0000q\u07cc\u0001\u0000\u0000\u0000s\u07d2\u0001\u0000\u0000"+ + "\u0000u\u07d5\u0001\u0000\u0000\u0000w\u07d9\u0001\u0000\u0000\u0000y"+ + "\u07e4\u0001\u0000\u0000\u0000{\u07ee\u0001\u0000\u0000\u0000}\u07f9\u0001"+ + "\u0000\u0000\u0000\u007f\u0804\u0001\u0000\u0000\u0000\u0081\u0807\u0001"+ + "\u0000\u0000\u0000\u0083\u080e\u0001\u0000\u0000\u0000\u0085\u0818\u0001"+ + "\u0000\u0000\u0000\u0087\u0823\u0001\u0000\u0000\u0000\u0089\u0831\u0001"+ + "\u0000\u0000\u0000\u008b\u0835\u0001\u0000\u0000\u0000\u008d\u083e\u0001"+ + "\u0000\u0000\u0000\u008f\u0845\u0001\u0000\u0000\u0000\u0091\u084b\u0001"+ + "\u0000\u0000\u0000\u0093\u0855\u0001\u0000\u0000\u0000\u0095\u085d\u0001"+ + "\u0000\u0000\u0000\u0097\u0864\u0001\u0000\u0000\u0000\u0099\u086b\u0001"+ + "\u0000\u0000\u0000\u009b\u086f\u0001\u0000\u0000\u0000\u009d\u087a\u0001"+ + "\u0000\u0000\u0000\u009f\u0881\u0001\u0000\u0000\u0000\u00a1\u0886\u0001"+ + "\u0000\u0000\u0000\u00a3\u088e\u0001\u0000\u0000\u0000\u00a5\u0893\u0001"+ + "\u0000\u0000\u0000\u00a7\u089b\u0001\u0000\u0000\u0000\u00a9\u08a3\u0001"+ + "\u0000\u0000\u0000\u00ab\u08a6\u0001\u0000\u0000\u0000\u00ad\u08a8\u0001"+ + "\u0000\u0000\u0000\u00af\u08ae\u0001\u0000\u0000\u0000\u00b1\u08b3\u0001"+ + "\u0000\u0000\u0000\u00b3\u08ba\u0001\u0000\u0000\u0000\u00b5\u08c6\u0001"+ + "\u0000\u0000\u0000\u00b7\u08ce\u0001\u0000\u0000\u0000\u00b9\u08d7\u0001"+ + "\u0000\u0000\u0000\u00bb\u08dc\u0001\u0000\u0000\u0000\u00bd\u08e1\u0001"+ + "\u0000\u0000\u0000\u00bf\u08e9\u0001\u0000\u0000\u0000\u00c1\u08f6\u0001"+ + "\u0000\u0000\u0000\u00c3\u08fb\u0001\u0000\u0000\u0000\u00c5\u0903\u0001"+ + "\u0000\u0000\u0000\u00c7\u0909\u0001\u0000\u0000\u0000\u00c9\u090e\u0001"+ + "\u0000\u0000\u0000\u00cb\u091a\u0001\u0000\u0000\u0000\u00cd\u0924\u0001"+ + "\u0000\u0000\u0000\u00cf\u0935\u0001\u0000\u0000\u0000\u00d1\u094b\u0001"+ + "\u0000\u0000\u0000\u00d3\u095e\u0001\u0000\u0000\u0000\u00d5\u0973\u0001"+ + "\u0000\u0000\u0000\u00d7\u0983\u0001\u0000\u0000\u0000\u00d9\u098e\u0001"+ + "\u0000\u0000\u0000\u00db\u0994\u0001\u0000\u0000\u0000\u00dd\u099c\u0001"+ + "\u0000\u0000\u0000\u00df\u09a7\u0001\u0000\u0000\u0000\u00e1\u09ad\u0001"+ + "\u0000\u0000\u0000\u00e3\u09ba\u0001\u0000\u0000\u0000\u00e5\u09bf\u0001"+ + "\u0000\u0000\u0000\u00e7\u09c5\u0001\u0000\u0000\u0000\u00e9\u09cd\u0001"+ + "\u0000\u0000\u0000\u00eb\u09d6\u0001\u0000\u0000\u0000\u00ed\u09dc\u0001"+ + "\u0000\u0000\u0000\u00ef\u09e4\u0001\u0000\u0000\u0000\u00f1\u09ee\u0001"+ + "\u0000\u0000\u0000\u00f3\u0a00\u0001\u0000\u0000\u0000\u00f5\u0a0f\u0001"+ + "\u0000\u0000\u0000\u00f7\u0a20\u0001\u0000\u0000\u0000\u00f9\u0a28\u0001"+ + "\u0000\u0000\u0000\u00fb\u0a2f\u0001\u0000\u0000\u0000\u00fd\u0a3b\u0001"+ + "\u0000\u0000\u0000\u00ff\u0a4c\u0001\u0000\u0000\u0000\u0101\u0a62\u0001"+ + "\u0000\u0000\u0000\u0103\u0a6a\u0001\u0000\u0000\u0000\u0105\u0a71\u0001"+ + "\u0000\u0000\u0000\u0107\u0a7b\u0001\u0000\u0000\u0000\u0109\u0a86\u0001"+ + "\u0000\u0000\u0000\u010b\u0a90\u0001\u0000\u0000\u0000\u010d\u0aa1\u0001"+ + "\u0000\u0000\u0000\u010f\u0aaf\u0001\u0000\u0000\u0000\u0111\u0ab8\u0001"+ + "\u0000\u0000\u0000\u0113\u0ac0\u0001\u0000\u0000\u0000\u0115\u0acb\u0001"+ + "\u0000\u0000\u0000\u0117\u0adb\u0001\u0000\u0000\u0000\u0119\u0ae6\u0001"+ + "\u0000\u0000\u0000\u011b\u0af9\u0001\u0000\u0000\u0000\u011d\u0b09\u0001"+ + "\u0000\u0000\u0000\u011f\u0b1b\u0001\u0000\u0000\u0000\u0121\u0b27\u0001"+ + "\u0000\u0000\u0000\u0123\u0b33\u0001\u0000\u0000\u0000\u0125\u0b3c\u0001"+ + "\u0000\u0000\u0000\u0127\u0b45\u0001\u0000\u0000\u0000\u0129\u0b50\u0001"+ + "\u0000\u0000\u0000\u012b\u0b58\u0001\u0000\u0000\u0000\u012d\u0b5d\u0001"+ + "\u0000\u0000\u0000\u012f\u0b62\u0001\u0000\u0000\u0000\u0131\u0b70\u0001"+ + "\u0000\u0000\u0000\u0133\u0b76\u0001\u0000\u0000\u0000\u0135\u0b7c\u0001"+ + "\u0000\u0000\u0000\u0137\u0b86\u0001\u0000\u0000\u0000\u0139\u0b91\u0001"+ + "\u0000\u0000\u0000\u013b\u0b98\u0001\u0000\u0000\u0000\u013d\u0ba1\u0001"+ + "\u0000\u0000\u0000\u013f\u0bac\u0001\u0000\u0000\u0000\u0141\u0bb2\u0001"+ + "\u0000\u0000\u0000\u0143\u0bb6\u0001\u0000\u0000\u0000\u0145\u0bbb\u0001"+ + "\u0000\u0000\u0000\u0147\u0bc5\u0001\u0000\u0000\u0000\u0149\u0bcd\u0001"+ + "\u0000\u0000\u0000\u014b\u0bda\u0001\u0000\u0000\u0000\u014d\u0bfa\u0001"+ + "\u0000\u0000\u0000\u014f\u0c07\u0001\u0000\u0000\u0000\u0151\u0c14\u0001"+ + "\u0000\u0000\u0000\u0153\u0c21\u0001\u0000\u0000\u0000\u0155\u0c33\u0001"+ + "\u0000\u0000\u0000\u0157\u0c54\u0001\u0000\u0000\u0000\u0159\u0c61\u0001"+ + "\u0000\u0000\u0000\u015b\u0c68\u0001\u0000\u0000\u0000\u015d\u0c74\u0001"+ + "\u0000\u0000\u0000\u015f\u0c7a\u0001\u0000\u0000\u0000\u0161\u0c7f\u0001"+ + "\u0000\u0000\u0000\u0163\u0c88\u0001\u0000\u0000\u0000\u0165\u0c8d\u0001"+ + "\u0000\u0000\u0000\u0167\u0ca4\u0001\u0000\u0000\u0000\u0169\u0cc0\u0001"+ + "\u0000\u0000\u0000\u016b\u0cc4\u0001\u0000\u0000\u0000\u016d\u0ccf\u0001"+ + "\u0000\u0000\u0000\u016f\u0cd3\u0001\u0000\u0000\u0000\u0171\u0cdb\u0001"+ + "\u0000\u0000\u0000\u0173\u0ce3\u0001\u0000\u0000\u0000\u0175\u0ceb\u0001"+ + "\u0000\u0000\u0000\u0177\u0cf4\u0001\u0000\u0000\u0000\u0179\u0cfe\u0001"+ + "\u0000\u0000\u0000\u017b\u0d09\u0001\u0000\u0000\u0000\u017d\u0d12\u0001"+ + "\u0000\u0000\u0000\u017f\u0d1a\u0001\u0000\u0000\u0000\u0181\u0d22\u0001"+ + "\u0000\u0000\u0000\u0183\u0d29\u0001\u0000\u0000\u0000\u0185\u0d30\u0001"+ + "\u0000\u0000\u0000\u0187\u0d3a\u0001\u0000\u0000\u0000\u0189\u0d45\u0001"+ + "\u0000\u0000\u0000\u018b\u0d50\u0001\u0000\u0000\u0000\u018d\u0d58\u0001"+ + "\u0000\u0000\u0000\u018f\u0d5e\u0001\u0000\u0000\u0000\u0191\u0d64\u0001"+ + "\u0000\u0000\u0000\u0193\u0d6c\u0001\u0000\u0000\u0000\u0195\u0d71\u0001"+ + "\u0000\u0000\u0000\u0197\u0d7a\u0001\u0000\u0000\u0000\u0199\u0d85\u0001"+ + "\u0000\u0000\u0000\u019b\u0d8d\u0001\u0000\u0000\u0000\u019d\u0d98\u0001"+ + "\u0000\u0000\u0000\u019f\u0da6\u0001\u0000\u0000\u0000\u01a1\u0db2\u0001"+ + "\u0000\u0000\u0000\u01a3\u0dbd\u0001\u0000\u0000\u0000\u01a5\u0dc5\u0001"+ + "\u0000\u0000\u0000\u01a7\u0ddb\u0001\u0000\u0000\u0000\u01a9\u0de3\u0001"+ + "\u0000\u0000\u0000\u01ab\u0dee\u0001\u0000\u0000\u0000\u01ad\u0df7\u0001"+ + "\u0000\u0000\u0000\u01af\u0e00\u0001\u0000\u0000\u0000\u01b1\u0e03\u0001"+ + "\u0000\u0000\u0000\u01b3\u0e0a\u0001\u0000\u0000\u0000\u01b5\u0e11\u0001"+ + "\u0000\u0000\u0000\u01b7\u0e16\u0001\u0000\u0000\u0000\u01b9\u0e1e\u0001"+ + "\u0000\u0000\u0000\u01bb\u0e2f\u0001\u0000\u0000\u0000\u01bd\u0e45\u0001"+ + "\u0000\u0000\u0000\u01bf\u0e4a\u0001\u0000\u0000\u0000\u01c1\u0e52\u0001"+ + "\u0000\u0000\u0000\u01c3\u0e57\u0001\u0000\u0000\u0000\u01c5\u0e5e\u0001"+ + "\u0000\u0000\u0000\u01c7\u0e67\u0001\u0000\u0000\u0000\u01c9\u0e71\u0001"+ + "\u0000\u0000\u0000\u01cb\u0e75\u0001\u0000\u0000\u0000\u01cd\u0e7e\u0001"+ + "\u0000\u0000\u0000\u01cf\u0e85\u0001\u0000\u0000\u0000\u01d1\u0e8c\u0001"+ + "\u0000\u0000\u0000\u01d3\u0e92\u0001\u0000\u0000\u0000\u01d5\u0e99\u0001"+ + "\u0000\u0000\u0000\u01d7\u0ea3\u0001\u0000\u0000\u0000\u01d9\u0eab\u0001"+ + "\u0000\u0000\u0000\u01db\u0eb5\u0001\u0000\u0000\u0000\u01dd\u0ebf\u0001"+ + "\u0000\u0000\u0000\u01df\u0ec4\u0001\u0000\u0000\u0000\u01e1\u0ecc\u0001"+ + "\u0000\u0000\u0000\u01e3\u0ed5\u0001\u0000\u0000\u0000\u01e5\u0edc\u0001"+ + "\u0000\u0000\u0000\u01e7\u0ee0\u0001\u0000\u0000\u0000\u01e9\u0ee8\u0001"+ + "\u0000\u0000\u0000\u01eb\u0ef1\u0001\u0000\u0000\u0000\u01ed\u0efb\u0001"+ + "\u0000\u0000\u0000\u01ef\u0f04\u0001\u0000\u0000\u0000\u01f1\u0f0c\u0001"+ + "\u0000\u0000\u0000\u01f3\u0f12\u0001\u0000\u0000\u0000\u01f5\u0f18\u0001"+ + "\u0000\u0000\u0000\u01f7\u0f1f\u0001\u0000\u0000\u0000\u01f9\u0f26\u0001"+ + "\u0000\u0000\u0000\u01fb\u0f2c\u0001\u0000\u0000\u0000\u01fd\u0f32\u0001"+ + "\u0000\u0000\u0000\u01ff\u0f38\u0001\u0000\u0000\u0000\u0201\u0f3e\u0001"+ + "\u0000\u0000\u0000\u0203\u0f48\u0001\u0000\u0000\u0000\u0205\u0f4c\u0001"+ + "\u0000\u0000\u0000\u0207\u0f52\u0001\u0000\u0000\u0000\u0209\u0f5a\u0001"+ + "\u0000\u0000\u0000\u020b\u0f61\u0001\u0000\u0000\u0000\u020d\u0f69\u0001"+ + "\u0000\u0000\u0000\u020f\u0f71\u0001\u0000\u0000\u0000\u0211\u0f77\u0001"+ + "\u0000\u0000\u0000\u0213\u0f7c\u0001\u0000\u0000\u0000\u0215\u0f83\u0001"+ + "\u0000\u0000\u0000\u0217\u0f88\u0001\u0000\u0000\u0000\u0219\u0f8d\u0001"+ + "\u0000\u0000\u0000\u021b\u0f96\u0001\u0000\u0000\u0000\u021d\u0f9d\u0001"+ + "\u0000\u0000\u0000\u021f\u0f9f\u0001\u0000\u0000\u0000\u0221\u0fa7\u0001"+ + "\u0000\u0000\u0000\u0223\u0fb1\u0001\u0000\u0000\u0000\u0225\u0fb5\u0001"+ + "\u0000\u0000\u0000\u0227\u0fbc\u0001\u0000\u0000\u0000\u0229\u0fbf\u0001"+ + "\u0000\u0000\u0000\u022b\u0fc4\u0001\u0000\u0000\u0000\u022d\u0fca\u0001"+ + "\u0000\u0000\u0000\u022f\u0fd2\u0001\u0000\u0000\u0000\u0231\u0fdb\u0001"+ + "\u0000\u0000\u0000\u0233\u0fe1\u0001\u0000\u0000\u0000\u0235\u0fea\u0001"+ + "\u0000\u0000\u0000\u0237\u0ff2\u0001\u0000\u0000\u0000\u0239\u0ff9\u0001"+ + "\u0000\u0000\u0000\u023b\u1003\u0001\u0000\u0000\u0000\u023d\u1008\u0001"+ + "\u0000\u0000\u0000\u023f\u100d\u0001\u0000\u0000\u0000\u0241\u1012\u0001"+ + "\u0000\u0000\u0000\u0243\u101b\u0001\u0000\u0000\u0000\u0245\u1022\u0001"+ + "\u0000\u0000\u0000\u0247\u1028\u0001\u0000\u0000\u0000\u0249\u1032\u0001"+ + "\u0000\u0000\u0000\u024b\u103c\u0001\u0000\u0000\u0000\u024d\u104b\u0001"+ + "\u0000\u0000\u0000\u024f\u1054\u0001\u0000\u0000\u0000\u0251\u1057\u0001"+ + "\u0000\u0000\u0000\u0253\u1061\u0001\u0000\u0000\u0000\u0255\u106b\u0001"+ + "\u0000\u0000\u0000\u0257\u1071\u0001\u0000\u0000\u0000\u0259\u107b\u0001"+ + "\u0000\u0000\u0000\u025b\u1081\u0001\u0000\u0000\u0000\u025d\u108a\u0001"+ + "\u0000\u0000\u0000\u025f\u1095\u0001\u0000\u0000\u0000\u0261\u109f\u0001"+ + "\u0000\u0000\u0000\u0263\u10a5\u0001\u0000\u0000\u0000\u0265\u10ab\u0001"+ + "\u0000\u0000\u0000\u0267\u10b1\u0001\u0000\u0000\u0000\u0269\u10bd\u0001"+ + "\u0000\u0000\u0000\u026b\u10c4\u0001\u0000\u0000\u0000\u026d\u10cd\u0001"+ + "\u0000\u0000\u0000\u026f\u10da\u0001\u0000\u0000\u0000\u0271\u10e2\u0001"+ + "\u0000\u0000\u0000\u0273\u10e6\u0001\u0000\u0000\u0000\u0275\u10ee\u0001"+ + "\u0000\u0000\u0000\u0277\u10f8\u0001\u0000\u0000\u0000\u0279\u1105\u0001"+ + "\u0000\u0000\u0000\u027b\u110e\u0001\u0000\u0000\u0000\u027d\u1113\u0001"+ + "\u0000\u0000\u0000\u027f\u111b\u0001\u0000\u0000\u0000\u0281\u111e\u0001"+ + "\u0000\u0000\u0000\u0283\u1128\u0001\u0000\u0000\u0000\u0285\u1130\u0001"+ + "\u0000\u0000\u0000\u0287\u1135\u0001\u0000\u0000\u0000\u0289\u1137\u0001"+ + "\u0000\u0000\u0000\u028b\u113b\u0001\u0000\u0000\u0000\u028d\u1146\u0001"+ + "\u0000\u0000\u0000\u028f\u114f\u0001\u0000\u0000\u0000\u0291\u1155\u0001"+ + "\u0000\u0000\u0000\u0293\u1161\u0001\u0000\u0000\u0000\u0295\u116a\u0001"+ + "\u0000\u0000\u0000\u0297\u1170\u0001\u0000\u0000\u0000\u0299\u1175\u0001"+ + "\u0000\u0000\u0000\u029b\u117d\u0001\u0000\u0000\u0000\u029d\u1185\u0001"+ + "\u0000\u0000\u0000\u029f\u118b\u0001\u0000\u0000\u0000\u02a1\u1190\u0001"+ + "\u0000\u0000\u0000\u02a3\u1197\u0001\u0000\u0000\u0000\u02a5\u119c\u0001"+ + "\u0000\u0000\u0000\u02a7\u11a2\u0001\u0000\u0000\u0000\u02a9\u11a7\u0001"+ + "\u0000\u0000\u0000\u02ab\u11ad\u0001\u0000\u0000\u0000\u02ad\u11b4\u0001"+ + "\u0000\u0000\u0000\u02af\u11b7\u0001\u0000\u0000\u0000\u02b1\u11bc\u0001"+ + "\u0000\u0000\u0000\u02b3\u11c2\u0001\u0000\u0000\u0000\u02b5\u11cc\u0001"+ + "\u0000\u0000\u0000\u02b7\u11db\u0001\u0000\u0000\u0000\u02b9\u11e4\u0001"+ + "\u0000\u0000\u0000\u02bb\u11ec\u0001\u0000\u0000\u0000\u02bd\u11f1\u0001"+ + "\u0000\u0000\u0000\u02bf\u11f8\u0001\u0000\u0000\u0000\u02c1\u11fe\u0001"+ + "\u0000\u0000\u0000\u02c3\u1200\u0001\u0000\u0000\u0000\u02c5\u1205\u0001"+ + "\u0000\u0000\u0000\u02c7\u1209\u0001\u0000\u0000\u0000\u02c9\u1211\u0001"+ + "\u0000\u0000\u0000\u02cb\u1217\u0001\u0000\u0000\u0000\u02cd\u1224\u0001"+ + "\u0000\u0000\u0000\u02cf\u122c\u0001\u0000\u0000\u0000\u02d1\u1230\u0001"+ + "\u0000\u0000\u0000\u02d3\u1239\u0001\u0000\u0000\u0000\u02d5\u1240\u0001"+ + "\u0000\u0000\u0000\u02d7\u1246\u0001\u0000\u0000\u0000\u02d9\u1255\u0001"+ + "\u0000\u0000\u0000\u02db\u126a\u0001\u0000\u0000\u0000\u02dd\u1277\u0001"+ + "\u0000\u0000\u0000\u02df\u127e\u0001\u0000\u0000\u0000\u02e1\u1282\u0001"+ + "\u0000\u0000\u0000\u02e3\u1289\u0001\u0000\u0000\u0000\u02e5\u1292\u0001"+ + "\u0000\u0000\u0000\u02e7\u1296\u0001\u0000\u0000\u0000\u02e9\u129b\u0001"+ + "\u0000\u0000\u0000\u02eb\u12a4\u0001\u0000\u0000\u0000\u02ed\u12ab\u0001"+ + "\u0000\u0000\u0000\u02ef\u12b2\u0001\u0000\u0000\u0000\u02f1\u12b8\u0001"+ + "\u0000\u0000\u0000\u02f3\u12bd\u0001\u0000\u0000\u0000\u02f5\u12c2\u0001"+ + "\u0000\u0000\u0000\u02f7\u12cb\u0001\u0000\u0000\u0000\u02f9\u12d1\u0001"+ + "\u0000\u0000\u0000\u02fb\u12d6\u0001\u0000\u0000\u0000\u02fd\u12dc\u0001"+ + "\u0000\u0000\u0000\u02ff\u12e5\u0001\u0000\u0000\u0000\u0301\u12ed\u0001"+ + "\u0000\u0000\u0000\u0303\u12f3\u0001\u0000\u0000\u0000\u0305\u12f9\u0001"+ + "\u0000\u0000\u0000\u0307\u1301\u0001\u0000\u0000\u0000\u0309\u1305\u0001"+ + "\u0000\u0000\u0000\u030b\u130a\u0001\u0000\u0000\u0000\u030d\u130d\u0001"+ + "\u0000\u0000\u0000\u030f\u1318\u0001\u0000\u0000\u0000\u0311\u1325\u0001"+ + "\u0000\u0000\u0000\u0313\u132a\u0001\u0000\u0000\u0000\u0315\u1334\u0001"+ + "\u0000\u0000\u0000\u0317\u133f\u0001\u0000\u0000\u0000\u0319\u1343\u0001"+ + "\u0000\u0000\u0000\u031b\u134b\u0001\u0000\u0000\u0000\u031d\u1352\u0001"+ + "\u0000\u0000\u0000\u031f\u135a\u0001\u0000\u0000\u0000\u0321\u1361\u0001"+ + "\u0000\u0000\u0000\u0323\u1366\u0001\u0000\u0000\u0000\u0325\u136f\u0001"+ + "\u0000\u0000\u0000\u0327\u1376\u0001\u0000\u0000\u0000\u0329\u137c\u0001"+ + "\u0000\u0000\u0000\u032b\u1383\u0001\u0000\u0000\u0000\u032d\u138b\u0001"+ + "\u0000\u0000\u0000\u032f\u1392\u0001\u0000\u0000\u0000\u0331\u139f\u0001"+ + "\u0000\u0000\u0000\u0333\u13a6\u0001\u0000\u0000\u0000\u0335\u13a9\u0001"+ + "\u0000\u0000\u0000\u0337\u13ad\u0001\u0000\u0000\u0000\u0339\u13b4\u0001"+ + "\u0000\u0000\u0000\u033b\u13b9\u0001\u0000\u0000\u0000\u033d\u13bd\u0001"+ + "\u0000\u0000\u0000\u033f\u13c0\u0001\u0000\u0000\u0000\u0341\u13c5\u0001"+ + "\u0000\u0000\u0000\u0343\u13ca\u0001\u0000\u0000\u0000\u0345\u13d4\u0001"+ + "\u0000\u0000\u0000\u0347\u13dd\u0001\u0000\u0000\u0000\u0349\u13e4\u0001"+ + "\u0000\u0000\u0000\u034b\u13ec\u0001\u0000\u0000\u0000\u034d\u13ef\u0001"+ + "\u0000\u0000\u0000\u034f\u13f5\u0001\u0000\u0000\u0000\u0351\u13fe\u0001"+ + "\u0000\u0000\u0000\u0353\u1409\u0001\u0000\u0000\u0000\u0355\u1410\u0001"+ + "\u0000\u0000\u0000\u0357\u1414\u0001\u0000\u0000\u0000\u0359\u141a\u0001"+ + "\u0000\u0000\u0000\u035b\u1421\u0001\u0000\u0000\u0000\u035d\u1426\u0001"+ + "\u0000\u0000\u0000\u035f\u142f\u0001\u0000\u0000\u0000\u0361\u1437\u0001"+ + "\u0000\u0000\u0000\u0363\u1442\u0001\u0000\u0000\u0000\u0365\u1448\u0001"+ + "\u0000\u0000\u0000\u0367\u144c\u0001\u0000\u0000\u0000\u0369\u1456\u0001"+ + "\u0000\u0000\u0000\u036b\u1465\u0001\u0000\u0000\u0000\u036d\u1474\u0001"+ + "\u0000\u0000\u0000\u036f\u148f\u0001\u0000\u0000\u0000\u0371\u14aa\u0001"+ + "\u0000\u0000\u0000\u0373\u14c2\u0001\u0000\u0000\u0000\u0375\u14dc\u0001"+ + "\u0000\u0000\u0000\u0377\u14e7\u0001\u0000\u0000\u0000\u0379\u14ee\u0001"+ + "\u0000\u0000\u0000\u037b\u14f6\u0001\u0000\u0000\u0000\u037d\u1500\u0001"+ + "\u0000\u0000\u0000\u037f\u1507\u0001\u0000\u0000\u0000\u0381\u1510\u0001"+ + "\u0000\u0000\u0000\u0383\u1515\u0001\u0000\u0000\u0000\u0385\u1522\u0001"+ + "\u0000\u0000\u0000\u0387\u1532\u0001\u0000\u0000\u0000\u0389\u1542\u0001"+ + "\u0000\u0000\u0000\u038b\u154a\u0001\u0000\u0000\u0000\u038d\u1550\u0001"+ + "\u0000\u0000\u0000\u038f\u1556\u0001\u0000\u0000\u0000\u0391\u155a\u0001"+ + "\u0000\u0000\u0000\u0393\u1563\u0001\u0000\u0000\u0000\u0395\u156b\u0001"+ + "\u0000\u0000\u0000\u0397\u1571\u0001\u0000\u0000\u0000\u0399\u157b\u0001"+ + "\u0000\u0000\u0000\u039b\u1585\u0001\u0000\u0000\u0000\u039d\u158c\u0001"+ + "\u0000\u0000\u0000\u039f\u1595\u0001\u0000\u0000\u0000\u03a1\u159d\u0001"+ + "\u0000\u0000\u0000\u03a3\u15a6\u0001\u0000\u0000\u0000\u03a5\u15af\u0001"+ + "\u0000\u0000\u0000\u03a7\u15b7\u0001\u0000\u0000\u0000\u03a9\u15bd\u0001"+ + "\u0000\u0000\u0000\u03ab\u15c8\u0001\u0000\u0000\u0000\u03ad\u15d3\u0001"+ + "\u0000\u0000\u0000\u03af\u15dd\u0001\u0000\u0000\u0000\u03b1\u15e4\u0001"+ + "\u0000\u0000\u0000\u03b3\u15f0\u0001\u0000\u0000\u0000\u03b5\u15f6\u0001"+ + "\u0000\u0000\u0000\u03b7\u15fc\u0001\u0000\u0000\u0000\u03b9\u1601\u0001"+ + "\u0000\u0000\u0000\u03bb\u1606\u0001\u0000\u0000\u0000\u03bd\u160c\u0001"+ + "\u0000\u0000\u0000\u03bf\u1611\u0001\u0000\u0000\u0000\u03c1\u161a\u0001"+ + "\u0000\u0000\u0000\u03c3\u1622\u0001\u0000\u0000\u0000\u03c5\u162c\u0001"+ + "\u0000\u0000\u0000\u03c7\u1630\u0001\u0000\u0000\u0000\u03c9\u163b\u0001"+ + "\u0000\u0000\u0000\u03cb\u1647\u0001\u0000\u0000\u0000\u03cd\u164f\u0001"+ + "\u0000\u0000\u0000\u03cf\u1659\u0001\u0000\u0000\u0000\u03d1\u1663\u0001"+ + "\u0000\u0000\u0000\u03d3\u166e\u0001\u0000\u0000\u0000\u03d5\u167d\u0001"+ + "\u0000\u0000\u0000\u03d7\u1685\u0001\u0000\u0000\u0000\u03d9\u1690\u0001"+ + "\u0000\u0000\u0000\u03db\u1699\u0001\u0000\u0000\u0000\u03dd\u16a2\u0001"+ + "\u0000\u0000\u0000\u03df\u16ab\u0001\u0000\u0000\u0000\u03e1\u16b3\u0001"+ + "\u0000\u0000\u0000\u03e3\u16bc\u0001\u0000\u0000\u0000\u03e5\u16c4\u0001"+ + "\u0000\u0000\u0000\u03e7\u16cb\u0001\u0000\u0000\u0000\u03e9\u16d6\u0001"+ + "\u0000\u0000\u0000\u03eb\u16de\u0001\u0000\u0000\u0000\u03ed\u16e6\u0001"+ + "\u0000\u0000\u0000\u03ef\u16ec\u0001\u0000\u0000\u0000\u03f1\u16f4\u0001"+ + "\u0000\u0000\u0000\u03f3\u16fd\u0001\u0000\u0000\u0000\u03f5\u1704\u0001"+ + "\u0000\u0000\u0000\u03f7\u170b\u0001\u0000\u0000\u0000\u03f9\u1720\u0001"+ + "\u0000\u0000\u0000\u03fb\u1730\u0001\u0000\u0000\u0000\u03fd\u1746\u0001"+ + "\u0000\u0000\u0000\u03ff\u1758\u0001\u0000\u0000\u0000\u0401\u1762\u0001"+ + "\u0000\u0000\u0000\u0403\u176a\u0001\u0000\u0000\u0000\u0405\u1771\u0001"+ + "\u0000\u0000\u0000\u0407\u1777\u0001\u0000\u0000\u0000\u0409\u177c\u0001"+ + "\u0000\u0000\u0000\u040b\u1785\u0001\u0000\u0000\u0000\u040d\u178c\u0001"+ + "\u0000\u0000\u0000\u040f\u1794\u0001\u0000\u0000\u0000\u0411\u17a4\u0001"+ + "\u0000\u0000\u0000\u0413\u17b1\u0001\u0000\u0000\u0000\u0415\u17c0\u0001"+ + "\u0000\u0000\u0000\u0417\u17c4\u0001\u0000\u0000\u0000\u0419\u17ce\u0001"+ + "\u0000\u0000\u0000\u041b\u17d9\u0001\u0000\u0000\u0000\u041d\u17de\u0001"+ + "\u0000\u0000\u0000\u041f\u17e3\u0001\u0000\u0000\u0000\u0421\u17ed\u0001"+ + "\u0000\u0000\u0000\u0423\u17f3\u0001\u0000\u0000\u0000\u0425\u17fa\u0001"+ + "\u0000\u0000\u0000\u0427\u1806\u0001\u0000\u0000\u0000\u0429\u180c\u0001"+ + "\u0000\u0000\u0000\u042b\u181a\u0001\u0000\u0000\u0000\u042d\u1825\u0001"+ + "\u0000\u0000\u0000\u042f\u1832\u0001\u0000\u0000\u0000\u0431\u1839\u0001"+ + "\u0000\u0000\u0000\u0433\u1840\u0001\u0000\u0000\u0000\u0435\u1847\u0001"+ + "\u0000\u0000\u0000\u0437\u184f\u0001\u0000\u0000\u0000\u0439\u1858\u0001"+ + "\u0000\u0000\u0000\u043b\u185f\u0001\u0000\u0000\u0000\u043d\u1864\u0001"+ + "\u0000\u0000\u0000\u043f\u186e\u0001\u0000\u0000\u0000\u0441\u1877\u0001"+ + "\u0000\u0000\u0000\u0443\u1881\u0001\u0000\u0000\u0000\u0445\u188e\u0001"+ + "\u0000\u0000\u0000\u0447\u189a\u0001\u0000\u0000\u0000\u0449\u18a2\u0001"+ + "\u0000\u0000\u0000\u044b\u18af\u0001\u0000\u0000\u0000\u044d\u18b3\u0001"+ + "\u0000\u0000\u0000\u044f\u18b9\u0001\u0000\u0000\u0000\u0451\u18be\u0001"+ + "\u0000\u0000\u0000\u0453\u18c4\u0001\u0000\u0000\u0000\u0455\u18c9\u0001"+ + "\u0000\u0000\u0000\u0457\u18d1\u0001\u0000\u0000\u0000\u0459\u18d8\u0001"+ + "\u0000\u0000\u0000\u045b\u18dd\u0001\u0000\u0000\u0000\u045d\u18e2\u0001"+ + "\u0000\u0000\u0000\u045f\u18eb\u0001\u0000\u0000\u0000\u0461\u18f4\u0001"+ + "\u0000\u0000\u0000\u0463\u18f9\u0001\u0000\u0000\u0000\u0465\u1900\u0001"+ + "\u0000\u0000\u0000\u0467\u1906\u0001\u0000\u0000\u0000\u0469\u190f\u0001"+ + "\u0000\u0000\u0000\u046b\u191d\u0001\u0000\u0000\u0000\u046d\u192a\u0001"+ + "\u0000\u0000\u0000\u046f\u192e\u0001\u0000\u0000\u0000\u0471\u1936\u0001"+ + "\u0000\u0000\u0000\u0473\u193f\u0001\u0000\u0000\u0000\u0475\u194c\u0001"+ + "\u0000\u0000\u0000\u0477\u1955\u0001\u0000\u0000\u0000\u0479\u1960\u0001"+ + "\u0000\u0000\u0000\u047b\u1965\u0001\u0000\u0000\u0000\u047d\u196c\u0001"+ + "\u0000\u0000\u0000\u047f\u1972\u0001\u0000\u0000\u0000\u0481\u1978\u0001"+ + "\u0000\u0000\u0000\u0483\u1982\u0001\u0000\u0000\u0000\u0485\u1989\u0001"+ + "\u0000\u0000\u0000\u0487\u1994\u0001\u0000\u0000\u0000\u0489\u199f\u0001"+ + "\u0000\u0000\u0000\u048b\u19ab\u0001\u0000\u0000\u0000\u048d\u19b1\u0001"+ + "\u0000\u0000\u0000\u048f\u19b8\u0001\u0000\u0000\u0000\u0491\u19c0\u0001"+ + "\u0000\u0000\u0000\u0493\u19c7\u0001\u0000\u0000\u0000\u0495\u19d1\u0001"+ + "\u0000\u0000\u0000\u0497\u19d7\u0001\u0000\u0000\u0000\u0499\u19e7\u0001"+ + "\u0000\u0000\u0000\u049b\u19ef\u0001\u0000\u0000\u0000\u049d\u19fb\u0001"+ + "\u0000\u0000\u0000\u049f\u1a08\u0001\u0000\u0000\u0000\u04a1\u1a12\u0001"+ + "\u0000\u0000\u0000\u04a3\u1a16\u0001\u0000\u0000\u0000\u04a5\u1a20\u0001"+ + "\u0000\u0000\u0000\u04a7\u1a26\u0001\u0000\u0000\u0000\u04a9\u1a2d\u0001"+ + "\u0000\u0000\u0000\u04ab\u1a39\u0001\u0000\u0000\u0000\u04ad\u1a3f\u0001"+ + "\u0000\u0000\u0000\u04af\u1a4a\u0001\u0000\u0000\u0000\u04b1\u1a56\u0001"+ + "\u0000\u0000\u0000\u04b3\u1a61\u0001\u0000\u0000\u0000\u04b5\u1a66\u0001"+ + "\u0000\u0000\u0000\u04b7\u1a6f\u0001\u0000\u0000\u0000\u04b9\u1a79\u0001"+ + "\u0000\u0000\u0000\u04bb\u1a83\u0001\u0000\u0000\u0000\u04bd\u1a88\u0001"+ + "\u0000\u0000\u0000\u04bf\u1a8d\u0001\u0000\u0000\u0000\u04c1\u1a92\u0001"+ + "\u0000\u0000\u0000\u04c3\u1a97\u0001\u0000\u0000\u0000\u04c5\u1aa1\u0001"+ + "\u0000\u0000\u0000\u04c7\u1aaf\u0001\u0000\u0000\u0000\u04c9\u1abf\u0001"+ + "\u0000\u0000\u0000\u04cb\u1ac6\u0001\u0000\u0000\u0000\u04cd\u1ac9\u0001"+ + "\u0000\u0000\u0000\u04cf\u1acf\u0001\u0000\u0000\u0000\u04d1\u1adf\u0001"+ + "\u0000\u0000\u0000\u04d3\u1ae8\u0001\u0000\u0000\u0000\u04d5\u1af4\u0001"+ + "\u0000\u0000\u0000\u04d7\u1b07\u0001\u0000\u0000\u0000\u04d9\u1b1e\u0001"+ + "\u0000\u0000\u0000\u04db\u1b37\u0001\u0000\u0000\u0000\u04dd\u1b41\u0001"+ + "\u0000\u0000\u0000\u04df\u1b4c\u0001\u0000\u0000\u0000\u04e1\u1b56\u0001"+ + "\u0000\u0000\u0000\u04e3\u1b62\u0001\u0000\u0000\u0000\u04e5\u1b68\u0001"+ + "\u0000\u0000\u0000\u04e7\u1b70\u0001\u0000\u0000\u0000\u04e9\u1b80\u0001"+ + "\u0000\u0000\u0000\u04eb\u1b8d\u0001\u0000\u0000\u0000\u04ed\u1b9c\u0001"+ + "\u0000\u0000\u0000\u04ef\u1ba1\u0001\u0000\u0000\u0000\u04f1\u1ba6\u0001"+ + "\u0000\u0000\u0000\u04f3\u1baf\u0001\u0000\u0000\u0000\u04f5\u1bb7\u0001"+ + "\u0000\u0000\u0000\u04f7\u1bbc\u0001\u0000\u0000\u0000\u04f9\u1bc4\u0001"+ + "\u0000\u0000\u0000\u04fb\u1bce\u0001\u0000\u0000\u0000\u04fd\u1bda\u0001"+ + "\u0000\u0000\u0000\u04ff\u1be0\u0001\u0000\u0000\u0000\u0501\u1bec\u0001"+ + "\u0000\u0000\u0000\u0503\u1bf2\u0001\u0000\u0000\u0000\u0505\u1bf9\u0001"+ + "\u0000\u0000\u0000\u0507\u1c01\u0001\u0000\u0000\u0000\u0509\u1c0a\u0001"+ + "\u0000\u0000\u0000\u050b\u1c13\u0001\u0000\u0000\u0000\u050d\u1c1b\u0001"+ + "\u0000\u0000\u0000\u050f\u1c22\u0001\u0000\u0000\u0000\u0511\u1c28\u0001"+ + "\u0000\u0000\u0000\u0513\u1c2f\u0001\u0000\u0000\u0000\u0515\u1c35\u0001"+ + "\u0000\u0000\u0000\u0517\u1c3b\u0001\u0000\u0000\u0000\u0519\u1c40\u0001"+ + "\u0000\u0000\u0000\u051b\u1c5a\u0001\u0000\u0000\u0000\u051d\u1c71\u0001"+ + "\u0000\u0000\u0000\u051f\u1c88\u0001\u0000\u0000\u0000\u0521\u1ca1\u0001"+ + "\u0000\u0000\u0000\u0523\u1ca7\u0001\u0000\u0000\u0000\u0525\u1cae\u0001"+ + "\u0000\u0000\u0000\u0527\u1cb4\u0001\u0000\u0000\u0000\u0529\u1cbd\u0001"+ + "\u0000\u0000\u0000\u052b\u1cc7\u0001\u0000\u0000\u0000\u052d\u1ccd\u0001"+ + "\u0000\u0000\u0000\u052f\u1cd4\u0001\u0000\u0000\u0000\u0531\u1cdc\u0001"+ + "\u0000\u0000\u0000\u0533\u1ce5\u0001\u0000\u0000\u0000\u0535\u1ced\u0001"+ + "\u0000\u0000\u0000\u0537\u1cf6\u0001\u0000\u0000\u0000\u0539\u1cff\u0001"+ + "\u0000\u0000\u0000\u053b\u1d07\u0001\u0000\u0000\u0000\u053d\u1d0f\u0001"+ + "\u0000\u0000\u0000\u053f\u1d14\u0001\u0000\u0000\u0000\u0541\u1d1d\u0001"+ + "\u0000\u0000\u0000\u0543\u1d22\u0001\u0000\u0000\u0000\u0545\u1d2b\u0001"+ + "\u0000\u0000\u0000\u0547\u1d31\u0001\u0000\u0000\u0000\u0549\u1d3e\u0001"+ + "\u0000\u0000\u0000\u054b\u1d45\u0001\u0000\u0000\u0000\u054d\u1d4a\u0001"+ + "\u0000\u0000\u0000\u054f\u1d51\u0001\u0000\u0000\u0000\u0551\u1d59\u0001"+ + "\u0000\u0000\u0000\u0553\u1d5e\u0001\u0000\u0000\u0000\u0555\u1d64\u0001"+ + "\u0000\u0000\u0000\u0557\u1d69\u0001\u0000\u0000\u0000\u0559\u1d6e\u0001"+ + "\u0000\u0000\u0000\u055b\u1d72\u0001\u0000\u0000\u0000\u055d\u1d77\u0001"+ + "\u0000\u0000\u0000\u055f\u1d81\u0001\u0000\u0000\u0000\u0561\u1d8d\u0001"+ + "\u0000\u0000\u0000\u0563\u1d98\u0001\u0000\u0000\u0000\u0565\u1da5\u0001"+ + "\u0000\u0000\u0000\u0567\u1dad\u0001\u0000\u0000\u0000\u0569\u1db7\u0001"+ + "\u0000\u0000\u0000\u056b\u1dbd\u0001\u0000\u0000\u0000\u056d\u1dc5\u0001"+ + "\u0000\u0000\u0000\u056f\u1dd1\u0001\u0000\u0000\u0000\u0571\u1ddf\u0001"+ + "\u0000\u0000\u0000\u0573\u1de9\u0001\u0000\u0000\u0000\u0575\u1df5\u0001"+ + "\u0000\u0000\u0000\u0577\u1dfb\u0001\u0000\u0000\u0000\u0579\u1e01\u0001"+ + "\u0000\u0000\u0000\u057b\u1e08\u0001\u0000\u0000\u0000\u057d\u1e12\u0001"+ + "\u0000\u0000\u0000\u057f\u1e22\u0001\u0000\u0000\u0000\u0581\u1e2e\u0001"+ + "\u0000\u0000\u0000\u0583\u1e39\u0001\u0000\u0000\u0000\u0585\u1e46\u0001"+ + "\u0000\u0000\u0000\u0587\u1e4f\u0001\u0000\u0000\u0000\u0589\u1e56\u0001"+ + "\u0000\u0000\u0000\u058b\u1e5f\u0001\u0000\u0000\u0000\u058d\u1e66\u0001"+ + "\u0000\u0000\u0000\u058f\u1e6e\u0001\u0000\u0000\u0000\u0591\u1e79\u0001"+ + "\u0000\u0000\u0000\u0593\u1e8a\u0001\u0000\u0000\u0000\u0595\u1e94\u0001"+ + "\u0000\u0000\u0000\u0597\u1e9b\u0001\u0000\u0000\u0000\u0599\u1ea4\u0001"+ + "\u0000\u0000\u0000\u059b\u1eb1\u0001\u0000\u0000\u0000\u059d\u1eb6\u0001"+ + "\u0000\u0000\u0000\u059f\u1ec1\u0001\u0000\u0000\u0000\u05a1\u1ec8\u0001"+ + "\u0000\u0000\u0000\u05a3\u1ed1\u0001\u0000\u0000\u0000\u05a5\u1ed4\u0001"+ + "\u0000\u0000\u0000\u05a7\u1edb\u0001\u0000\u0000\u0000\u05a9\u1ee6\u0001"+ + "\u0000\u0000\u0000\u05ab\u1eef\u0001\u0000\u0000\u0000\u05ad\u1ef8\u0001"+ + "\u0000\u0000\u0000\u05af\u1f00\u0001\u0000\u0000\u0000\u05b1\u1f12\u0001"+ + "\u0000\u0000\u0000\u05b3\u1f1e\u0001\u0000\u0000\u0000\u05b5\u1f24\u0001"+ + "\u0000\u0000\u0000\u05b7\u1f2c\u0001\u0000\u0000\u0000\u05b9\u1f33\u0001"+ + "\u0000\u0000\u0000\u05bb\u1f39\u0001\u0000\u0000\u0000\u05bd\u1f3e\u0001"+ + "\u0000\u0000\u0000\u05bf\u1f43\u0001\u0000\u0000\u0000\u05c1\u1f4a\u0001"+ + "\u0000\u0000\u0000\u05c3\u1f4e\u0001\u0000\u0000\u0000\u05c5\u1f53\u0001"+ + "\u0000\u0000\u0000\u05c7\u1f60\u0001\u0000\u0000\u0000\u05c9\u1f67\u0001"+ + "\u0000\u0000\u0000\u05cb\u1f74\u0001\u0000\u0000\u0000\u05cd\u1f7c\u0001"+ + "\u0000\u0000\u0000\u05cf\u1f85\u0001\u0000\u0000\u0000\u05d1\u1f90\u0001"+ + "\u0000\u0000\u0000\u05d3\u1f98\u0001\u0000\u0000\u0000\u05d5\u1f9f\u0001"+ + "\u0000\u0000\u0000\u05d7\u1fa6\u0001\u0000\u0000\u0000\u05d9\u1fad\u0001"+ + "\u0000\u0000\u0000\u05db\u1fb4\u0001\u0000\u0000\u0000\u05dd\u1fba\u0001"+ + "\u0000\u0000\u0000\u05df\u1fc2\u0001\u0000\u0000\u0000\u05e1\u1fcc\u0001"+ + "\u0000\u0000\u0000\u05e3\u1fd8\u0001\u0000\u0000\u0000\u05e5\u1fdd\u0001"+ + "\u0000\u0000\u0000\u05e7\u1fe1\u0001\u0000\u0000\u0000\u05e9\u1fe7\u0001"+ + "\u0000\u0000\u0000\u05eb\u1ff9\u0001\u0000\u0000\u0000\u05ed\u1ffe\u0001"+ + "\u0000\u0000\u0000\u05ef\u2005\u0001\u0000\u0000\u0000\u05f1\u200c\u0001"+ + "\u0000\u0000\u0000\u05f3\u2013\u0001\u0000\u0000\u0000\u05f5\u2018\u0001"+ + "\u0000\u0000\u0000\u05f7\u201d\u0001\u0000\u0000\u0000\u05f9\u2022\u0001"+ + "\u0000\u0000\u0000\u05fb\u2027\u0001\u0000\u0000\u0000\u05fd\u202c\u0001"+ + "\u0000\u0000\u0000\u05ff\u2032\u0001\u0000\u0000\u0000\u0601\u2037\u0001"+ + "\u0000\u0000\u0000\u0603\u203c\u0001\u0000\u0000\u0000\u0605\u2044\u0001"+ + "\u0000\u0000\u0000\u0607\u204d\u0001\u0000\u0000\u0000\u0609\u2053\u0001"+ + "\u0000\u0000\u0000\u060b\u205a\u0001\u0000\u0000\u0000\u060d\u2060\u0001"+ + "\u0000\u0000\u0000\u060f\u2068\u0001\u0000\u0000\u0000\u0611\u2070\u0001"+ + "\u0000\u0000\u0000\u0613\u2077\u0001\u0000\u0000\u0000\u0615\u207f\u0001"+ + "\u0000\u0000\u0000\u0617\u2087\u0001\u0000\u0000\u0000\u0619\u208f\u0001"+ + "\u0000\u0000\u0000\u061b\u209b\u0001\u0000\u0000\u0000\u061d\u20a2\u0001"+ + "\u0000\u0000\u0000\u061f\u20a7\u0001\u0000\u0000\u0000\u0621\u20b3\u0001"+ + "\u0000\u0000\u0000\u0623\u20ba\u0001\u0000\u0000\u0000\u0625\u20c2\u0001"+ + "\u0000\u0000\u0000\u0627\u20cb\u0001\u0000\u0000\u0000\u0629\u20d9\u0001"+ + "\u0000\u0000\u0000\u062b\u20de\u0001\u0000\u0000\u0000\u062d\u20e5\u0001"+ + "\u0000\u0000\u0000\u062f\u20e9\u0001\u0000\u0000\u0000\u0631\u20eb\u0001"+ + "\u0000\u0000\u0000\u0633\u20ed\u0001\u0000\u0000\u0000\u0635\u20f0\u0001"+ + "\u0000\u0000\u0000\u0637\u20f2\u0001\u0000\u0000\u0000\u0639\u20f5\u0001"+ + "\u0000\u0000\u0000\u063b\u20f7\u0001\u0000\u0000\u0000\u063d\u20f9\u0001"+ + "\u0000\u0000\u0000\u063f\u20fb\u0001\u0000\u0000\u0000\u0641\u20fd\u0001"+ + "\u0000\u0000\u0000\u0643\u20ff\u0001\u0000\u0000\u0000\u0645\u2109\u0001"+ + "\u0000\u0000\u0000\u0647\u210d\u0001\u0000\u0000\u0000\u0649\u2129\u0001"+ + "\u0000\u0000\u0000\u064b\u2138\u0001\u0000\u0000\u0000\u064d\u213b\u0001"+ + "\u0000\u0000\u0000\u064f\u213d\u0001\u0000\u0000\u0000\u0651\u213f\u0001"+ + "\u0000\u0000\u0000\u0653\u2141\u0001\u0000\u0000\u0000\u0655\u2148\u0001"+ + "\u0000\u0000\u0000\u0657\u214e\u0001\u0000\u0000\u0000\u0659\u2155\u0001"+ + "\u0000\u0000\u0000\u065b\u2157\u0001\u0000\u0000\u0000\u065d\u215a\u0001"+ + "\u0000\u0000\u0000\u065f\u215d\u0001\u0000\u0000\u0000\u0661\u2160\u0001"+ + "\u0000\u0000\u0000\u0663\u2163\u0001\u0000\u0000\u0000\u0665\u2165\u0001"+ + "\u0000\u0000\u0000\u0667\u2167\u0001\u0000\u0000\u0000\u0669\u216a\u0001"+ + "\u0000\u0000\u0000\u066b\u216d\u0001\u0000\u0000\u0000\u066d\u216f\u0001"+ + "\u0000\u0000\u0000\u066f\u2171\u0001\u0000\u0000\u0000\u0671\u2174\u0001"+ + "\u0000\u0000\u0000\u0673\u2176\u0001\u0000\u0000\u0000\u0675\u2179\u0001"+ + "\u0000\u0000\u0000\u0677\u217c\u0001\u0000\u0000\u0000\u0679\u217e\u0001"+ + "\u0000\u0000\u0000\u067b\u2181\u0001\u0000\u0000\u0000\u067d\u2184\u0001"+ + "\u0000\u0000\u0000\u067f\u2188\u0001\u0000\u0000\u0000\u0681\u218b\u0001"+ + "\u0000\u0000\u0000\u0683\u218e\u0001\u0000\u0000\u0000\u0685\u2192\u0001"+ + "\u0000\u0000\u0000\u0687\u2196\u0001\u0000\u0000\u0000\u0689\u2198\u0001"+ + "\u0000\u0000\u0000\u068b\u219b\u0001\u0000\u0000\u0000\u068d\u219e\u0001"+ + "\u0000\u0000\u0000\u068f\u21a1\u0001\u0000\u0000\u0000\u0691\u21a4\u0001"+ + "\u0000\u0000\u0000\u0693\u21a8\u0001\u0000\u0000\u0000\u0695\u21ab\u0001"+ + "\u0000\u0000\u0000\u0697\u21af\u0001\u0000\u0000\u0000\u0699\u21b3\u0001"+ + "\u0000\u0000\u0000\u069b\u21b5\u0001\u0000\u0000\u0000\u069d\u21b7\u0001"+ + "\u0000\u0000\u0000\u069f\u21b9\u0001\u0000\u0000\u0000\u06a1\u21bc\u0001"+ + "\u0000\u0000\u0000\u06a3\u21c0\u0001\u0000\u0000\u0000\u06a5\u21c3\u0001"+ + "\u0000\u0000\u0000\u06a7\u21c5\u0001\u0000\u0000\u0000\u06a9\u21c7\u0001"+ + "\u0000\u0000\u0000\u06ab\u21ca\u0001\u0000\u0000\u0000\u06ad\u21cd\u0001"+ + "\u0000\u0000\u0000\u06af\u21d0\u0001\u0000\u0000\u0000\u06b1\u21d3\u0001"+ + "\u0000\u0000\u0000\u06b3\u21d5\u0001\u0000\u0000\u0000\u06b5\u21d7\u0001"+ + "\u0000\u0000\u0000\u06b7\u21da\u0001\u0000\u0000\u0000\u06b9\u21df\u0001"+ + "\u0000\u0000\u0000\u06bb\u21e3\u0001\u0000\u0000\u0000\u06bd\u21e8\u0001"+ + "\u0000\u0000\u0000\u06bf\u21ec\u0001\u0000\u0000\u0000\u06c1\u21ef\u0001"+ + "\u0000\u0000\u0000\u06c3\u21f2\u0001\u0000\u0000\u0000\u06c5\u21f4\u0001"+ + "\u0000\u0000\u0000\u06c7\u21fd\u0001\u0000\u0000\u0000\u06c9\u06cb\u0007"+ + "\u0000\u0000\u0000\u06ca\u06c9\u0001\u0000\u0000\u0000\u06cb\u06cc\u0001"+ + "\u0000\u0000\u0000\u06cc\u06ca\u0001\u0000\u0000\u0000\u06cc\u06cd\u0001"+ + "\u0000\u0000\u0000\u06cd\u06ce\u0001\u0000\u0000\u0000\u06ce\u06cf\u0006"+ + "\u0000\u0000\u0000\u06cf\u0002\u0001\u0000\u0000\u0000\u06d0\u06d1\u0005"+ + "/\u0000\u0000\u06d1\u06d2\u0005*\u0000\u0000\u06d2\u06d6\u0001\u0000\u0000"+ + "\u0000\u06d3\u06d5\t\u0000\u0000\u0000\u06d4\u06d3\u0001\u0000\u0000\u0000"+ + "\u06d5\u06d8\u0001\u0000\u0000\u0000\u06d6\u06d7\u0001\u0000\u0000\u0000"+ + "\u06d6\u06d4\u0001\u0000\u0000\u0000\u06d7\u06d9\u0001\u0000\u0000\u0000"+ + "\u06d8\u06d6\u0001\u0000\u0000\u0000\u06d9\u06da\u0005*\u0000\u0000\u06da"+ + "\u06db\u0005/\u0000\u0000\u06db\u06dc\u0001\u0000\u0000\u0000\u06dc\u06dd"+ + "\u0006\u0001\u0001\u0000\u06dd\u0004\u0001\u0000\u0000\u0000\u06de\u06df"+ + "\u0005-\u0000\u0000\u06df\u06e0\u0005-\u0000\u0000\u06e0\u06e4\u0001\u0000"+ + "\u0000\u0000\u06e1\u06e3\t\u0000\u0000\u0000\u06e2\u06e1\u0001\u0000\u0000"+ + "\u0000\u06e3\u06e6\u0001\u0000\u0000\u0000\u06e4\u06e5\u0001\u0000\u0000"+ + "\u0000\u06e4\u06e2\u0001\u0000\u0000\u0000\u06e5\u06e7\u0001\u0000\u0000"+ + "\u0000\u06e6\u06e4\u0001\u0000\u0000\u0000\u06e7\u06e8\u0005\n\u0000\u0000"+ + "\u06e8\u06e9\u0001\u0000\u0000\u0000\u06e9\u06ea\u0006\u0002\u0001\u0000"+ + "\u06ea\u0006\u0001\u0000\u0000\u0000\u06eb\u06ec\u0007\u0001\u0000\u0000"+ + "\u06ec\b\u0001\u0000\u0000\u0000\u06ed\u06ee\u0007\u0002\u0000\u0000\u06ee"+ + "\n\u0001\u0000\u0000\u0000\u06ef\u06f0\u0007\u0003\u0000\u0000\u06f0\f"+ + "\u0001\u0000\u0000\u0000\u06f1\u06f2\u0007\u0004\u0000\u0000\u06f2\u000e"+ + "\u0001\u0000\u0000\u0000\u06f3\u06f4\u0007\u0005\u0000\u0000\u06f4\u0010"+ + "\u0001\u0000\u0000\u0000\u06f5\u06f6\u0007\u0006\u0000\u0000\u06f6\u0012"+ + "\u0001\u0000\u0000\u0000\u06f7\u06f8\u0007\u0007\u0000\u0000\u06f8\u0014"+ + "\u0001\u0000\u0000\u0000\u06f9\u06fa\u0007\b\u0000\u0000\u06fa\u0016\u0001"+ + "\u0000\u0000\u0000\u06fb\u06fc\u0007\t\u0000\u0000\u06fc\u0018\u0001\u0000"+ + "\u0000\u0000\u06fd\u06fe\u0007\n\u0000\u0000\u06fe\u001a\u0001\u0000\u0000"+ + "\u0000\u06ff\u0700\u0007\u000b\u0000\u0000\u0700\u001c\u0001\u0000\u0000"+ + "\u0000\u0701\u0702\u0007\f\u0000\u0000\u0702\u001e\u0001\u0000\u0000\u0000"+ + "\u0703\u0704\u0007\r\u0000\u0000\u0704 \u0001\u0000\u0000\u0000\u0705"+ + "\u0706\u0007\u000e\u0000\u0000\u0706\"\u0001\u0000\u0000\u0000\u0707\u0708"+ + "\u0007\u000f\u0000\u0000\u0708$\u0001\u0000\u0000\u0000\u0709\u070a\u0007"+ + "\u0010\u0000\u0000\u070a&\u0001\u0000\u0000\u0000\u070b\u070c\u0007\u0011"+ + "\u0000\u0000\u070c(\u0001\u0000\u0000\u0000\u070d\u070e\u0007\u0012\u0000"+ + "\u0000\u070e*\u0001\u0000\u0000\u0000\u070f\u0710\u0007\u0013\u0000\u0000"+ + "\u0710,\u0001\u0000\u0000\u0000\u0711\u0712\u0007\u0014\u0000\u0000\u0712"+ + ".\u0001\u0000\u0000\u0000\u0713\u0714\u0007\u0015\u0000\u0000\u07140\u0001"+ + "\u0000\u0000\u0000\u0715\u0716\u0007\u0016\u0000\u0000\u07162\u0001\u0000"+ + "\u0000\u0000\u0717\u0718\u0007\u0017\u0000\u0000\u07184\u0001\u0000\u0000"+ + "\u0000\u0719\u071a\u0007\u0018\u0000\u0000\u071a6\u0001\u0000\u0000\u0000"+ + "\u071b\u071c\u0007\u0019\u0000\u0000\u071c8\u0001\u0000\u0000\u0000\u071d"+ + "\u071e\u0007\u001a\u0000\u0000\u071e:\u0001\u0000\u0000\u0000\u071f\u0720"+ + "\u0007\u001b\u0000\u0000\u0720<\u0001\u0000\u0000\u0000\u0721\u0722\u0007"+ + "\u001c\u0000\u0000\u0722>\u0001\u0000\u0000\u0000\u0723\u072b\u0005\""+ + "\u0000\u0000\u0724\u0725\u0005\\\u0000\u0000\u0725\u072a\t\u0000\u0000"+ + "\u0000\u0726\u0727\u0005\"\u0000\u0000\u0727\u072a\u0005\"\u0000\u0000"+ + "\u0728\u072a\b\u001d\u0000\u0000\u0729\u0724\u0001\u0000\u0000\u0000\u0729"+ + "\u0726\u0001\u0000\u0000\u0000\u0729\u0728\u0001\u0000\u0000\u0000\u072a"+ + "\u072d\u0001\u0000\u0000\u0000\u072b\u0729\u0001\u0000\u0000\u0000\u072b"+ + "\u072c\u0001\u0000\u0000\u0000\u072c\u072e\u0001\u0000\u0000\u0000\u072d"+ + "\u072b\u0001\u0000\u0000\u0000\u072e\u072f\u0005\"\u0000\u0000\u072f@"+ + "\u0001\u0000\u0000\u0000\u0730\u0738\u0005\'\u0000\u0000\u0731\u0732\u0005"+ + "\\\u0000\u0000\u0732\u0737\t\u0000\u0000\u0000\u0733\u0734\u0005\'\u0000"+ + "\u0000\u0734\u0737\u0005\'\u0000\u0000\u0735\u0737\b\u001e\u0000\u0000"+ + "\u0736\u0731\u0001\u0000\u0000\u0000\u0736\u0733\u0001\u0000\u0000\u0000"+ + "\u0736\u0735\u0001\u0000\u0000\u0000\u0737\u073a\u0001\u0000\u0000\u0000"+ + "\u0738\u0736\u0001\u0000\u0000\u0000\u0738\u0739\u0001\u0000\u0000\u0000"+ + "\u0739\u073b\u0001\u0000\u0000\u0000\u073a\u0738\u0001\u0000\u0000\u0000"+ + "\u073b\u073c\u0005\'\u0000\u0000\u073cB\u0001\u0000\u0000\u0000\u073d"+ + "\u0745\u0005`\u0000\u0000\u073e\u073f\u0005\\\u0000\u0000\u073f\u0744"+ + "\t\u0000\u0000\u0000\u0740\u0741\u0005`\u0000\u0000\u0741\u0744\u0005"+ + "`\u0000\u0000\u0742\u0744\b\u001f\u0000\u0000\u0743\u073e\u0001\u0000"+ + "\u0000\u0000\u0743\u0740\u0001\u0000\u0000\u0000\u0743\u0742\u0001\u0000"+ + "\u0000\u0000\u0744\u0747\u0001\u0000\u0000\u0000\u0745\u0743\u0001\u0000"+ + "\u0000\u0000\u0745\u0746\u0001\u0000\u0000\u0000\u0746\u0748\u0001\u0000"+ + "\u0000\u0000\u0747\u0745\u0001\u0000\u0000\u0000\u0748\u0749\u0005`\u0000"+ + "\u0000\u0749D\u0001\u0000\u0000\u0000\u074a\u074b\u0003\u0007\u0003\u0000"+ + "\u074bF\u0001\u0000\u0000\u0000\u074c\u074d\u0003\u0007\u0003\u0000\u074d"+ + "\u074e\u0003\t\u0004\u0000\u074e\u074f\u0003#\u0011\u0000\u074f\u0750"+ + "\u0003)\u0014\u0000\u0750\u0751\u0003-\u0016\u0000\u0751H\u0001\u0000"+ + "\u0000\u0000\u0752\u0753\u0003\u0007\u0003\u0000\u0753\u0754\u0003\t\u0004"+ + "\u0000\u0754\u0755\u0003+\u0015\u0000\u0755J\u0001\u0000\u0000\u0000\u0756"+ + "\u0757\u0003\u0007\u0003\u0000\u0757\u0758\u0003\t\u0004\u0000\u0758\u0759"+ + "\u0003+\u0015\u0000\u0759\u075a\u0003#\u0011\u0000\u075a\u075b\u0003\u001d"+ + "\u000e\u0000\u075b\u075c\u0003/\u0017\u0000\u075c\u075d\u0003-\u0016\u0000"+ + "\u075d\u075e\u0003\u000f\u0007\u0000\u075eL\u0001\u0000\u0000\u0000\u075f"+ + "\u0760\u0003\u0007\u0003\u0000\u0760\u0761\u0003\u000b\u0005\u0000\u0761"+ + "\u0762\u0003\u000b\u0005\u0000\u0762\u0763\u0003\u000f\u0007\u0000\u0763"+ + "\u0764\u0003+\u0015\u0000\u0764\u0765\u0003+\u0015\u0000\u0765N\u0001"+ + "\u0000\u0000\u0000\u0766\u0767\u0003\u0007\u0003\u0000\u0767\u0768\u0003"+ + "\u000b\u0005\u0000\u0768\u0769\u0003-\u0016\u0000\u0769\u076a\u0003\u0017"+ + "\u000b\u0000\u076a\u076b\u0003#\u0011\u0000\u076b\u076c\u0003!\u0010\u0000"+ + "\u076cP\u0001\u0000\u0000\u0000\u076d\u076e\u0003\u0007\u0003\u0000\u076e"+ + "\u076f\u0003\r\u0006\u0000\u076f\u0770\u0003\u0007\u0003\u0000\u0770R"+ + "\u0001\u0000\u0000\u0000\u0771\u0772\u0003\u0007\u0003\u0000\u0772\u0773"+ + "\u0003\r\u0006\u0000\u0773\u0774\u0003\r\u0006\u0000\u0774T\u0001\u0000"+ + "\u0000\u0000\u0775\u0776\u0003\u0007\u0003\u0000\u0776\u0777\u0003\r\u0006"+ + "\u0000\u0777\u0778\u0003\u001f\u000f\u0000\u0778\u0779\u0003\u0017\u000b"+ + "\u0000\u0779\u077a\u0003!\u0010\u0000\u077aV\u0001\u0000\u0000\u0000\u077b"+ + "\u077c\u0003\u0007\u0003\u0000\u077c\u077d\u0003\u0011\b\u0000\u077d\u077e"+ + "\u0003-\u0016\u0000\u077e\u077f\u0003\u000f\u0007\u0000\u077f\u0780\u0003"+ + ")\u0014\u0000\u0780X\u0001\u0000\u0000\u0000\u0781\u0782\u0003\u0007\u0003"+ + "\u0000\u0782\u0783\u0003\u0013\t\u0000\u0783\u0784\u0003\u0013\t\u0000"+ + "\u0784\u0785\u0003)\u0014\u0000\u0785\u0786\u0003\u000f\u0007\u0000\u0786"+ + "\u0787\u0003\u0013\t\u0000\u0787\u0788\u0003\u0007\u0003\u0000\u0788\u0789"+ + "\u0003-\u0016\u0000\u0789\u078a\u0003\u000f\u0007\u0000\u078aZ\u0001\u0000"+ + "\u0000\u0000\u078b\u078c\u0003\u0007\u0003\u0000\u078c\u078d\u0003\u001d"+ + "\u000e\u0000\u078d\u078e\u0003\u0017\u000b\u0000\u078e\u078f\u0003\u0007"+ + "\u0003\u0000\u078f\u0790\u0003+\u0015\u0000\u0790\\\u0001\u0000\u0000"+ + "\u0000\u0791\u0792\u0003\u0007\u0003\u0000\u0792\u0793\u0003\u001d\u000e"+ + "\u0000\u0793\u0794\u0003\u001d\u000e\u0000\u0794^\u0001\u0000\u0000\u0000"+ + "\u0795\u0796\u0003\u0007\u0003\u0000\u0796\u0797\u0003\u001d\u000e\u0000"+ + "\u0797\u0798\u0003\u001d\u000e\u0000\u0798\u0799\u0003#\u0011\u0000\u0799"+ + "\u079a\u0003\u000b\u0005\u0000\u079a\u079b\u0003\u0007\u0003\u0000\u079b"+ + "\u079c\u0003-\u0016\u0000\u079c\u079d\u0003\u000f\u0007\u0000\u079d`\u0001"+ + "\u0000\u0000\u0000\u079e\u079f\u0003\u0007\u0003\u0000\u079f\u07a0\u0003"+ + "\u001d\u000e\u0000\u07a0\u07a1\u0003+\u0015\u0000\u07a1\u07a2\u0003#\u0011"+ + "\u0000\u07a2b\u0001\u0000\u0000\u0000\u07a3\u07a4\u0003\u0007\u0003\u0000"+ + "\u07a4\u07a5\u0003\u001d\u000e\u0000\u07a5\u07a6\u0003-\u0016\u0000\u07a6"+ + "\u07a7\u0003\u000f\u0007\u0000\u07a7\u07a8\u0003)\u0014\u0000\u07a8d\u0001"+ + "\u0000\u0000\u0000\u07a9\u07aa\u0003\u0007\u0003\u0000\u07aa\u07ab\u0003"+ + "\u001d\u000e\u0000\u07ab\u07ac\u00033\u0019\u0000\u07ac\u07ad\u0003\u0007"+ + "\u0003\u0000\u07ad\u07ae\u00037\u001b\u0000\u07ae\u07af\u0003+\u0015\u0000"+ + "\u07aff\u0001\u0000\u0000\u0000\u07b0\u07b1\u0003\u0007\u0003\u0000\u07b1"+ + "\u07b2\u0003!\u0010\u0000\u07b2\u07b3\u0003\u0007\u0003\u0000\u07b3\u07b4"+ + "\u0003\u001d\u000e\u0000\u07b4\u07b5\u00037\u001b\u0000\u07b5\u07b6\u0003"+ + "+\u0015\u0000\u07b6\u07b7\u0003\u000f\u0007\u0000\u07b7h\u0001\u0000\u0000"+ + "\u0000\u07b8\u07b9\u0003\u0007\u0003\u0000\u07b9\u07ba\u0003!\u0010\u0000"+ + "\u07ba\u07bb\u0003\u0007\u0003\u0000\u07bb\u07bc\u0003\u001d\u000e\u0000"+ + "\u07bc\u07bd\u00037\u001b\u0000\u07bd\u07be\u00039\u001c\u0000\u07be\u07bf"+ + "\u0003\u000f\u0007\u0000\u07bfj\u0001\u0000\u0000\u0000\u07c0\u07c1\u0003"+ + "\u0007\u0003\u0000\u07c1\u07c2\u0003!\u0010\u0000\u07c2\u07c3\u0003\r"+ + "\u0006\u0000\u07c3l\u0001\u0000\u0000\u0000\u07c4\u07c5\u0003\u0007\u0003"+ + "\u0000\u07c5\u07c6\u0003!\u0010\u0000\u07c6\u07c7\u00037\u001b\u0000\u07c7"+ + "n\u0001\u0000\u0000\u0000\u07c8\u07c9\u0003\u0007\u0003\u0000\u07c9\u07ca"+ + "\u0003)\u0014\u0000\u07ca\u07cb\u0003\u000f\u0007\u0000\u07cbp\u0001\u0000"+ + "\u0000\u0000\u07cc\u07cd\u0003\u0007\u0003\u0000\u07cd\u07ce\u0003)\u0014"+ + "\u0000\u07ce\u07cf\u0003)\u0014\u0000\u07cf\u07d0\u0003\u0007\u0003\u0000"+ + "\u07d0\u07d1\u00037\u001b\u0000\u07d1r\u0001\u0000\u0000\u0000\u07d2\u07d3"+ + "\u0003\u0007\u0003\u0000\u07d3\u07d4\u0003+\u0015\u0000\u07d4t\u0001\u0000"+ + "\u0000\u0000\u07d5\u07d6\u0003\u0007\u0003\u0000\u07d6\u07d7\u0003+\u0015"+ + "\u0000\u07d7\u07d8\u0003\u000b\u0005\u0000\u07d8v\u0001\u0000\u0000\u0000"+ + "\u07d9\u07da\u0003\u0007\u0003\u0000\u07da\u07db\u0003+\u0015\u0000\u07db"+ + "\u07dc\u0003\u000f\u0007\u0000\u07dc\u07dd\u0003!\u0010\u0000\u07dd\u07de"+ + "\u0003+\u0015\u0000\u07de\u07df\u0003\u0017\u000b\u0000\u07df\u07e0\u0003"+ + "-\u0016\u0000\u07e0\u07e1\u0003\u0017\u000b\u0000\u07e1\u07e2\u00031\u0018"+ + "\u0000\u07e2\u07e3\u0003\u000f\u0007\u0000\u07e3x\u0001\u0000\u0000\u0000"+ + "\u07e4\u07e5\u0003\u0007\u0003\u0000\u07e5\u07e6\u0003+\u0015\u0000\u07e6"+ + "\u07e7\u0003+\u0015\u0000\u07e7\u07e8\u0003\u000f\u0007\u0000\u07e8\u07e9"+ + "\u0003)\u0014\u0000\u07e9\u07ea\u0003-\u0016\u0000\u07ea\u07eb\u0003\u0017"+ + "\u000b\u0000\u07eb\u07ec\u0003#\u0011\u0000\u07ec\u07ed\u0003!\u0010\u0000"+ + "\u07edz\u0001\u0000\u0000\u0000\u07ee\u07ef\u0003\u0007\u0003\u0000\u07ef"+ + "\u07f0\u0003+\u0015\u0000\u07f0\u07f1\u0003+\u0015\u0000\u07f1\u07f2\u0003"+ + "\u0017\u000b\u0000\u07f2\u07f3\u0003\u0013\t\u0000\u07f3\u07f4\u0003!"+ + "\u0010\u0000\u07f4\u07f5\u0003\u001f\u000f\u0000\u07f5\u07f6\u0003\u000f"+ + "\u0007\u0000\u07f6\u07f7\u0003!\u0010\u0000\u07f7\u07f8\u0003-\u0016\u0000"+ + "\u07f8|\u0001\u0000\u0000\u0000\u07f9\u07fa\u0003\u0007\u0003\u0000\u07fa"+ + "\u07fb\u0003+\u0015\u0000\u07fb\u07fc\u00037\u001b\u0000\u07fc\u07fd\u0003"+ + "\u001f\u000f\u0000\u07fd\u07fe\u0003\u001f\u000f\u0000\u07fe\u07ff\u0003"+ + "\u000f\u0007\u0000\u07ff\u0800\u0003-\u0016\u0000\u0800\u0801\u0003)\u0014"+ + "\u0000\u0801\u0802\u0003\u0017\u000b\u0000\u0802\u0803\u0003\u000b\u0005"+ + "\u0000\u0803~\u0001\u0000\u0000\u0000\u0804\u0805\u0003\u0007\u0003\u0000"+ + "\u0805\u0806\u0003-\u0016\u0000\u0806\u0080\u0001\u0000\u0000\u0000\u0807"+ + "\u0808\u0003\u0007\u0003\u0000\u0808\u0809\u0003-\u0016\u0000\u0809\u080a"+ + "\u0003#\u0011\u0000\u080a\u080b\u0003\u001f\u000f\u0000\u080b\u080c\u0003"+ + "\u0017\u000b\u0000\u080c\u080d\u0003\u000b\u0005\u0000\u080d\u0082\u0001"+ + "\u0000\u0000\u0000\u080e\u080f\u0003\u0007\u0003\u0000\u080f\u0810\u0003"+ + "-\u0016\u0000\u0810\u0811\u0003-\u0016\u0000\u0811\u0812\u0003)\u0014"+ + "\u0000\u0812\u0813\u0003\u0017\u000b\u0000\u0813\u0814\u0003\t\u0004\u0000"+ + "\u0814\u0815\u0003/\u0017\u0000\u0815\u0816\u0003-\u0016\u0000\u0816\u0817"+ + "\u0003\u000f\u0007\u0000\u0817\u0084\u0001\u0000\u0000\u0000\u0818\u0819"+ + "\u0003\u0007\u0003\u0000\u0819\u081a\u0003-\u0016\u0000\u081a\u081b\u0003"+ + "-\u0016\u0000\u081b\u081c\u0003)\u0014\u0000\u081c\u081d\u0003\u0017\u000b"+ + "\u0000\u081d\u081e\u0003\t\u0004\u0000\u081e\u081f\u0003/\u0017\u0000"+ + "\u081f\u0820\u0003-\u0016\u0000\u0820\u0821\u0003\u000f\u0007\u0000\u0821"+ + "\u0822\u0003+\u0015\u0000\u0822\u0086\u0001\u0000\u0000\u0000\u0823\u0824"+ + "\u0003\u0007\u0003\u0000\u0824\u0825\u0003/\u0017\u0000\u0825\u0826\u0003"+ + "-\u0016\u0000\u0826\u0827\u0003\u0015\n\u0000\u0827\u0828\u0003#\u0011"+ + "\u0000\u0828\u0829\u0003)\u0014\u0000\u0829\u082a\u0003\u0017\u000b\u0000"+ + "\u082a\u082b\u00039\u001c\u0000\u082b\u082c\u0003\u0007\u0003\u0000\u082c"+ + "\u082d\u0003-\u0016\u0000\u082d\u082e\u0003\u0017\u000b\u0000\u082e\u082f"+ + "\u0003#\u0011\u0000\u082f\u0830\u0003!\u0010\u0000\u0830\u0088\u0001\u0000"+ + "\u0000\u0000\u0831\u0832\u0003\u0007\u0003\u0000\u0832\u0833\u00031\u0018"+ + "\u0000\u0833\u0834\u0003\u0013\t\u0000\u0834\u008a\u0001\u0000\u0000\u0000"+ + "\u0835\u0836\u0003\t\u0004\u0000\u0836\u0837\u0003\u0007\u0003\u0000\u0837"+ + "\u0838\u0003\u000b\u0005\u0000\u0838\u0839\u0003\u001b\r\u0000\u0839\u083a"+ + "\u00033\u0019\u0000\u083a\u083b\u0003\u0007\u0003\u0000\u083b\u083c\u0003"+ + ")\u0014\u0000\u083c\u083d\u0003\r\u0006\u0000\u083d\u008c\u0001\u0000"+ + "\u0000\u0000\u083e\u083f\u0003\t\u0004\u0000\u083f\u0840\u0003\u000f\u0007"+ + "\u0000\u0840\u0841\u0003\u0011\b\u0000\u0841\u0842\u0003#\u0011\u0000"+ + "\u0842\u0843\u0003)\u0014\u0000\u0843\u0844\u0003\u000f\u0007\u0000\u0844"+ + "\u008e\u0001\u0000\u0000\u0000\u0845\u0846\u0003\t\u0004\u0000\u0846\u0847"+ + "\u0003\u000f\u0007\u0000\u0847\u0848\u0003\u0013\t\u0000\u0848\u0849\u0003"+ + "\u0017\u000b\u0000\u0849\u084a\u0003!\u0010\u0000\u084a\u0090\u0001\u0000"+ + "\u0000\u0000\u084b\u084c\u0003\t\u0004\u0000\u084c\u084d\u0003\u000f\u0007"+ + "\u0000\u084d\u084e\u0003)\u0014\u0000\u084e\u084f\u0003!\u0010\u0000\u084f"+ + "\u0850\u0003#\u0011\u0000\u0850\u0851\u0003/\u0017\u0000\u0851\u0852\u0003"+ + "\u001d\u000e\u0000\u0852\u0853\u0003\u001d\u000e\u0000\u0853\u0854\u0003"+ + "\u0017\u000b\u0000\u0854\u0092\u0001\u0000\u0000\u0000\u0855\u0856\u0003"+ + "\t\u0004\u0000\u0856\u0857\u0003\u000f\u0007\u0000\u0857\u0858\u0003-"+ + "\u0016\u0000\u0858\u0859\u00033\u0019\u0000\u0859\u085a\u0003\u000f\u0007"+ + "\u0000\u085a\u085b\u0003\u000f\u0007\u0000\u085b\u085c\u0003!\u0010\u0000"+ + "\u085c\u0094\u0001\u0000\u0000\u0000\u085d\u085e\u0003\t\u0004\u0000\u085e"+ + "\u085f\u0003\u0017\u000b\u0000\u085f\u0860\u0003\u0013\t\u0000\u0860\u0861"+ + "\u0003\u0017\u000b\u0000\u0861\u0862\u0003!\u0010\u0000\u0862\u0863\u0003"+ + "-\u0016\u0000\u0863\u0096\u0001\u0000\u0000\u0000\u0864\u0865\u0003\t"+ + "\u0004\u0000\u0865\u0866\u0003\u0017\u000b\u0000\u0866\u0867\u0003!\u0010"+ + "\u0000\u0867\u0868\u0003\u0007\u0003\u0000\u0868\u0869\u0003)\u0014\u0000"+ + "\u0869\u086a\u00037\u001b\u0000\u086a\u0098\u0001\u0000\u0000\u0000\u086b"+ + "\u086c\u0003\t\u0004\u0000\u086c\u086d\u0003\u0017\u000b\u0000\u086d\u086e"+ + "\u0003-\u0016\u0000\u086e\u009a\u0001\u0000\u0000\u0000\u086f\u0870\u0003"+ + "\t\u0004\u0000\u0870\u0871\u0003\u0017\u000b\u0000\u0871\u0872\u0003-"+ + "\u0016\u0000\u0872\u0873\u0005_\u0000\u0000\u0873\u0874\u0003\u001d\u000e"+ + "\u0000\u0874\u0875\u0003\u000f\u0007\u0000\u0875\u0876\u0003!\u0010\u0000"+ + "\u0876\u0877\u0003\u0013\t\u0000\u0877\u0878\u0003-\u0016\u0000\u0878"+ + "\u0879\u0003\u0015\n\u0000\u0879\u009c\u0001\u0000\u0000\u0000\u087a\u087b"+ + "\u0003\t\u0004\u0000\u087b\u087c\u0003\u0017\u000b\u0000\u087c\u087d\u0003"+ + "-\u0016\u0000\u087d\u087e\u00031\u0018\u0000\u087e\u087f\u0003\u0007\u0003"+ + "\u0000\u087f\u0880\u0003)\u0014\u0000\u0880\u009e\u0001\u0000\u0000\u0000"+ + "\u0881\u0882\u0003\t\u0004\u0000\u0882\u0883\u0003\u001d\u000e\u0000\u0883"+ + "\u0884\u0003#\u0011\u0000\u0884\u0885\u0003\t\u0004\u0000\u0885\u00a0"+ + "\u0001\u0000\u0000\u0000\u0886\u0887\u0003\t\u0004\u0000\u0887\u0888\u0003"+ + "#\u0011\u0000\u0888\u0889\u0003#\u0011\u0000\u0889\u088a\u0003\u001d\u000e"+ + "\u0000\u088a\u088b\u0003\u000f\u0007\u0000\u088b\u088c\u0003\u0007\u0003"+ + "\u0000\u088c\u088d\u0003!\u0010\u0000\u088d\u00a2\u0001\u0000\u0000\u0000"+ + "\u088e\u088f\u0003\t\u0004\u0000\u088f\u0890\u0003#\u0011\u0000\u0890"+ + "\u0891\u0003-\u0016\u0000\u0891\u0892\u0003\u0015\n\u0000\u0892\u00a4"+ + "\u0001\u0000\u0000\u0000\u0893\u0894\u0003\t\u0004\u0000\u0894\u0895\u0003"+ + ")\u0014\u0000\u0895\u0896\u0003\u000f\u0007\u0000\u0896\u0897\u0003\u0007"+ + "\u0003\u0000\u0897\u0898\u0003\r\u0006\u0000\u0898\u0899\u0003-\u0016"+ + "\u0000\u0899\u089a\u0003\u0015\n\u0000\u089a\u00a6\u0001\u0000\u0000\u0000"+ + "\u089b\u089c\u0003\t\u0004\u0000\u089c\u089d\u0003/\u0017\u0000\u089d"+ + "\u089e\u0003\u0011\b\u0000\u089e\u089f\u0003\u0011\b\u0000\u089f\u08a0"+ + "\u0003\u000f\u0007\u0000\u08a0\u08a1\u0003)\u0014\u0000\u08a1\u08a2\u0003"+ + "+\u0015\u0000\u08a2\u00a8\u0001\u0000\u0000\u0000\u08a3\u08a4\u0003\t"+ + "\u0004\u0000\u08a4\u08a5\u00037\u001b\u0000\u08a5\u00aa\u0001\u0000\u0000"+ + "\u0000\u08a6\u08a7\u0003\u000b\u0005\u0000\u08a7\u00ac\u0001\u0000\u0000"+ + "\u0000\u08a8\u08a9\u0003\u000b\u0005\u0000\u08a9\u08aa\u0003\u0007\u0003"+ + "\u0000\u08aa\u08ab\u0003\u000b\u0005\u0000\u08ab\u08ac\u0003\u0015\n\u0000"+ + "\u08ac\u08ad\u0003\u000f\u0007\u0000\u08ad\u00ae\u0001\u0000\u0000\u0000"+ + "\u08ae\u08af\u0003\u000b\u0005\u0000\u08af\u08b0\u0003\u0007\u0003\u0000"+ + "\u08b0\u08b1\u0003\u001d\u000e\u0000\u08b1\u08b2\u0003\u001d\u000e\u0000"+ + "\u08b2\u00b0\u0001\u0000\u0000\u0000\u08b3\u08b4\u0003\u000b\u0005\u0000"+ + "\u08b4\u08b5\u0003\u0007\u0003\u0000\u08b5\u08b6\u0003\u001d\u000e\u0000"+ + "\u08b6\u08b7\u0003\u001d\u000e\u0000\u08b7\u08b8\u0003\u000f\u0007\u0000"+ + "\u08b8\u08b9\u0003\r\u0006\u0000\u08b9\u00b2\u0001\u0000\u0000\u0000\u08ba"+ + "\u08bb\u0003\u000b\u0005\u0000\u08bb\u08bc\u0003\u0007\u0003\u0000\u08bc"+ + "\u08bd\u0003)\u0014\u0000\u08bd\u08be\u0003\r\u0006\u0000\u08be\u08bf"+ + "\u0003\u0017\u000b\u0000\u08bf\u08c0\u0003!\u0010\u0000\u08c0\u08c1\u0003"+ + "\u0007\u0003\u0000\u08c1\u08c2\u0003\u001d\u000e\u0000\u08c2\u08c3\u0003"+ + "\u0017\u000b\u0000\u08c3\u08c4\u0003-\u0016\u0000\u08c4\u08c5\u00037\u001b"+ + "\u0000\u08c5\u00b4\u0001\u0000\u0000\u0000\u08c6\u08c7\u0003\u000b\u0005"+ + "\u0000\u08c7\u08c8\u0003\u0007\u0003\u0000\u08c8\u08c9\u0003+\u0015\u0000"+ + "\u08c9\u08ca\u0003\u000b\u0005\u0000\u08ca\u08cb\u0003\u0007\u0003\u0000"+ + "\u08cb\u08cc\u0003\r\u0006\u0000\u08cc\u08cd\u0003\u000f\u0007\u0000\u08cd"+ + "\u00b6\u0001\u0000\u0000\u0000\u08ce\u08cf\u0003\u000b\u0005\u0000\u08cf"+ + "\u08d0\u0003\u0007\u0003\u0000\u08d0\u08d1\u0003+\u0015\u0000\u08d1\u08d2"+ + "\u0003\u000b\u0005\u0000\u08d2\u08d3\u0003\u0007\u0003\u0000\u08d3\u08d4"+ + "\u0003\r\u0006\u0000\u08d4\u08d5\u0003\u000f\u0007\u0000\u08d5\u08d6\u0003"+ + "\r\u0006\u0000\u08d6\u00b8\u0001\u0000\u0000\u0000\u08d7\u08d8\u0003\u000b"+ + "\u0005\u0000\u08d8\u08d9\u0003\u0007\u0003\u0000\u08d9\u08da\u0003+\u0015"+ + "\u0000\u08da\u08db\u0003\u000f\u0007\u0000\u08db\u00ba\u0001\u0000\u0000"+ + "\u0000\u08dc\u08dd\u0003\u000b\u0005\u0000\u08dd\u08de\u0003\u0007\u0003"+ + "\u0000\u08de\u08df\u0003+\u0015\u0000\u08df\u08e0\u0003-\u0016\u0000\u08e0"+ + "\u00bc\u0001\u0000\u0000\u0000\u08e1\u08e2\u0003\u000b\u0005\u0000\u08e2"+ + "\u08e3\u0003\u0007\u0003\u0000\u08e3\u08e4\u0003-\u0016\u0000\u08e4\u08e5"+ + "\u0003\u0007\u0003\u0000\u08e5\u08e6\u0003\u001d\u000e\u0000\u08e6\u08e7"+ + "\u0003#\u0011\u0000\u08e7\u08e8\u0003\u0013\t\u0000\u08e8\u00be\u0001"+ + "\u0000\u0000\u0000\u08e9\u08ea\u0003\u000b\u0005\u0000\u08ea\u08eb\u0003"+ + "\u0007\u0003\u0000\u08eb\u08ec\u0003-\u0016\u0000\u08ec\u08ed\u0003\u0007"+ + "\u0003\u0000\u08ed\u08ee\u0003\u001d\u000e\u0000\u08ee\u08ef\u0003#\u0011"+ + "\u0000\u08ef\u08f0\u0003\u0013\t\u0000\u08f0\u08f1\u0005_\u0000\u0000"+ + "\u08f1\u08f2\u0003!\u0010\u0000\u08f2\u08f3\u0003\u0007\u0003\u0000\u08f3"+ + "\u08f4\u0003\u001f\u000f\u0000\u08f4\u08f5\u0003\u000f\u0007\u0000\u08f5"+ + "\u00c0\u0001\u0000\u0000\u0000\u08f6\u08f7\u0003\u000b\u0005\u0000\u08f7"+ + "\u08f8\u0003\u000f\u0007\u0000\u08f8\u08f9\u0003\u0017\u000b\u0000\u08f9"+ + "\u08fa\u0003\u001d\u000e\u0000\u08fa\u00c2\u0001\u0000\u0000\u0000\u08fb"+ + "\u08fc\u0003\u000b\u0005\u0000\u08fc\u08fd\u0003\u000f\u0007\u0000\u08fd"+ + "\u08fe\u0003\u0017\u000b\u0000\u08fe\u08ff\u0003\u001d\u000e\u0000\u08ff"+ + "\u0900\u0003\u0017\u000b\u0000\u0900\u0901\u0003!\u0010\u0000\u0901\u0902"+ + "\u0003\u0013\t\u0000\u0902\u00c4\u0001\u0000\u0000\u0000\u0903\u0904\u0003"+ + "\u000b\u0005\u0000\u0904\u0905\u0003\u0015\n\u0000\u0905\u0906\u0003\u0007"+ + "\u0003\u0000\u0906\u0907\u0003\u0017\u000b\u0000\u0907\u0908\u0003!\u0010"+ + "\u0000\u0908\u00c6\u0001\u0000\u0000\u0000\u0909\u090a\u0003\u000b\u0005"+ + "\u0000\u090a\u090b\u0003\u0015\n\u0000\u090b\u090c\u0003\u0007\u0003\u0000"+ + "\u090c\u090d\u0003)\u0014\u0000\u090d\u00c8\u0001\u0000\u0000\u0000\u090e"+ + "\u090f\u0003\u000b\u0005\u0000\u090f\u0910\u0003\u0015\n\u0000\u0910\u0911"+ + "\u0003\u0007\u0003\u0000\u0911\u0912\u0003)\u0014\u0000\u0912\u0913\u0005"+ + "_\u0000\u0000\u0913\u0914\u0003\u001d\u000e\u0000\u0914\u0915\u0003\u000f"+ + "\u0007\u0000\u0915\u0916\u0003!\u0010\u0000\u0916\u0917\u0003\u0013\t"+ + "\u0000\u0917\u0918\u0003-\u0016\u0000\u0918\u0919\u0003\u0015\n\u0000"+ + "\u0919\u00ca\u0001\u0000\u0000\u0000\u091a\u091b\u0003\u000b\u0005\u0000"+ + "\u091b\u091c\u0003\u0015\n\u0000\u091c\u091d\u0003\u0007\u0003\u0000\u091d"+ + "\u091e\u0003)\u0014\u0000\u091e\u091f\u0003\u0007\u0003\u0000\u091f\u0920"+ + "\u0003\u000b\u0005\u0000\u0920\u0921\u0003-\u0016\u0000\u0921\u0922\u0003"+ + "\u000f\u0007\u0000\u0922\u0923\u0003)\u0014\u0000\u0923\u00cc\u0001\u0000"+ + "\u0000\u0000\u0924\u0925\u0003\u000b\u0005\u0000\u0925\u0926\u0003\u0015"+ + "\n\u0000\u0926\u0927\u0003\u0007\u0003\u0000\u0927\u0928\u0003)\u0014"+ + "\u0000\u0928\u0929\u0003\u0007\u0003\u0000\u0929\u092a\u0003\u000b\u0005"+ + "\u0000\u092a\u092b\u0003-\u0016\u0000\u092b\u092c\u0003\u000f\u0007\u0000"+ + "\u092c\u092d\u0003)\u0014\u0000\u092d\u092e\u0005_\u0000\u0000\u092e\u092f"+ + "\u0003\u001d\u000e\u0000\u092f\u0930\u0003\u000f\u0007\u0000\u0930\u0931"+ + "\u0003!\u0010\u0000\u0931\u0932\u0003\u0013\t\u0000\u0932\u0933\u0003"+ + "-\u0016\u0000\u0933\u0934\u0003\u0015\n\u0000\u0934\u00ce\u0001\u0000"+ + "\u0000\u0000\u0935\u0936\u0003\u000b\u0005\u0000\u0936\u0937\u0003\u0015"+ + "\n\u0000\u0937\u0938\u0003\u0007\u0003\u0000\u0938\u0939\u0003)\u0014"+ + "\u0000\u0939\u093a\u0003\u0007\u0003\u0000\u093a\u093b\u0003\u000b\u0005"+ + "\u0000\u093b\u093c\u0003-\u0016\u0000\u093c\u093d\u0003\u000f\u0007\u0000"+ + "\u093d\u093e\u0003)\u0014\u0000\u093e\u093f\u0005_\u0000\u0000\u093f\u0940"+ + "\u0003+\u0015\u0000\u0940\u0941\u0003\u000f\u0007\u0000\u0941\u0942\u0003"+ + "-\u0016\u0000\u0942\u0943\u0005_\u0000\u0000\u0943\u0944\u0003\u000b\u0005"+ + "\u0000\u0944\u0945\u0003\u0007\u0003\u0000\u0945\u0946\u0003-\u0016\u0000"+ + "\u0946\u0947\u0003\u0007\u0003\u0000\u0947\u0948\u0003\u001d\u000e\u0000"+ + "\u0948\u0949\u0003#\u0011\u0000\u0949\u094a\u0003\u0013\t\u0000\u094a"+ + "\u00d0\u0001\u0000\u0000\u0000\u094b\u094c\u0003\u000b\u0005\u0000\u094c"+ + "\u094d\u0003\u0015\n\u0000\u094d\u094e\u0003\u0007\u0003\u0000\u094e\u094f"+ + "\u0003)\u0014\u0000\u094f\u0950\u0003\u0007\u0003\u0000\u0950\u0951\u0003"+ + "\u000b\u0005\u0000\u0951\u0952\u0003-\u0016\u0000\u0952\u0953\u0003\u000f"+ + "\u0007\u0000\u0953\u0954\u0003)\u0014\u0000\u0954\u0955\u0005_\u0000\u0000"+ + "\u0955\u0956\u0003+\u0015\u0000\u0956\u0957\u0003\u000f\u0007\u0000\u0957"+ + "\u0958\u0003-\u0016\u0000\u0958\u0959\u0005_\u0000\u0000\u0959\u095a\u0003"+ + "!\u0010\u0000\u095a\u095b\u0003\u0007\u0003\u0000\u095b\u095c\u0003\u001f"+ + "\u000f\u0000\u095c\u095d\u0003\u000f\u0007\u0000\u095d\u00d2\u0001\u0000"+ + "\u0000\u0000\u095e\u095f\u0003\u000b\u0005\u0000\u095f\u0960\u0003\u0015"+ + "\n\u0000\u0960\u0961\u0003\u0007\u0003\u0000\u0961\u0962\u0003)\u0014"+ + "\u0000\u0962\u0963\u0003\u0007\u0003\u0000\u0963\u0964\u0003\u000b\u0005"+ + "\u0000\u0964\u0965\u0003-\u0016\u0000\u0965\u0966\u0003\u000f\u0007\u0000"+ + "\u0966\u0967\u0003)\u0014\u0000\u0967\u0968\u0005_\u0000\u0000\u0968\u0969"+ + "\u0003+\u0015\u0000\u0969\u096a\u0003\u000f\u0007\u0000\u096a\u096b\u0003"+ + "-\u0016\u0000\u096b\u096c\u0005_\u0000\u0000\u096c\u096d\u0003+\u0015"+ + "\u0000\u096d\u096e\u0003\u000b\u0005\u0000\u096e\u096f\u0003\u0015\n\u0000"+ + "\u096f\u0970\u0003\u000f\u0007\u0000\u0970\u0971\u0003\u001f\u000f\u0000"+ + "\u0971\u0972\u0003\u0007\u0003\u0000\u0972\u00d4\u0001\u0000\u0000\u0000"+ + "\u0973\u0974\u0003\u000b\u0005\u0000\u0974\u0975\u0003\u0015\n\u0000\u0975"+ + "\u0976\u0003\u0007\u0003\u0000\u0976\u0977\u0003)\u0014\u0000\u0977\u0978"+ + "\u0003\u0007\u0003\u0000\u0978\u0979\u0003\u000b\u0005\u0000\u0979\u097a"+ + "\u0003-\u0016\u0000\u097a\u097b\u0003\u000f\u0007\u0000\u097b\u097c\u0003"+ + ")\u0014\u0000\u097c\u097d\u0003\u0017\u000b\u0000\u097d\u097e\u0003+\u0015"+ + "\u0000\u097e\u097f\u0003-\u0016\u0000\u097f\u0980\u0003\u0017\u000b\u0000"+ + "\u0980\u0981\u0003\u000b\u0005\u0000\u0981\u0982\u0003+\u0015\u0000\u0982"+ + "\u00d6\u0001\u0000\u0000\u0000\u0983\u0984\u0003\u000b\u0005\u0000\u0984"+ + "\u0985\u0003\u0015\n\u0000\u0985\u0986\u0003\u0007\u0003\u0000\u0986\u0987"+ + "\u0003)\u0014\u0000\u0987\u0988\u0003\u0007\u0003\u0000\u0988\u0989\u0003"+ + "\u000b\u0005\u0000\u0989\u098a\u0003-\u0016\u0000\u098a\u098b\u0003\u000f"+ + "\u0007\u0000\u098b\u098c\u0003)\u0014\u0000\u098c\u098d\u0003+\u0015\u0000"+ + "\u098d\u00d8\u0001\u0000\u0000\u0000\u098e\u098f\u0003\u000b\u0005\u0000"+ + "\u098f\u0990\u0003\u0015\n\u0000\u0990\u0991\u0003\u000f\u0007\u0000\u0991"+ + "\u0992\u0003\u000b\u0005\u0000\u0992\u0993\u0003\u001b\r\u0000\u0993\u00da"+ + "\u0001\u0000\u0000\u0000\u0994\u0995\u0003\u000b\u0005\u0000\u0995\u0996"+ + "\u0003\u0015\n\u0000\u0996\u0997\u0003\u000f\u0007\u0000\u0997\u0998\u0003"+ + "\u000b\u0005\u0000\u0998\u0999\u0003\u001b\r\u0000\u0999\u099a\u0003\u000f"+ + "\u0007\u0000\u099a\u099b\u0003\r\u0006\u0000\u099b\u00dc\u0001\u0000\u0000"+ + "\u0000\u099c\u099d\u0003\u000b\u0005\u0000\u099d\u099e\u0003\u0015\n\u0000"+ + "\u099e\u099f\u0003\u000f\u0007\u0000\u099f\u09a0\u0003\u000b\u0005\u0000"+ + "\u09a0\u09a1\u0003\u001b\r\u0000\u09a1\u09a2\u0003%\u0012\u0000\u09a2"+ + "\u09a3\u0003#\u0011\u0000\u09a3\u09a4\u0003\u0017\u000b\u0000\u09a4\u09a5"+ + "\u0003!\u0010\u0000\u09a5\u09a6\u0003-\u0016\u0000\u09a6\u00de\u0001\u0000"+ + "\u0000\u0000\u09a7\u09a8\u0003\u000b\u0005\u0000\u09a8\u09a9\u0003\u001d"+ + "\u000e\u0000\u09a9\u09aa\u0003\u0007\u0003\u0000\u09aa\u09ab\u0003+\u0015"+ + "\u0000\u09ab\u09ac\u0003+\u0015\u0000\u09ac\u00e0\u0001\u0000\u0000\u0000"+ + "\u09ad\u09ae\u0003\u000b\u0005\u0000\u09ae\u09af\u0003\u001d\u000e\u0000"+ + "\u09af\u09b0\u0003\u0007\u0003\u0000\u09b0\u09b1\u0003+\u0015\u0000\u09b1"+ + "\u09b2\u0003+\u0015\u0000\u09b2\u09b3\u0005_\u0000\u0000\u09b3\u09b4\u0003"+ + "#\u0011\u0000\u09b4\u09b5\u0003)\u0014\u0000\u09b5\u09b6\u0003\u0017\u000b"+ + "\u0000\u09b6\u09b7\u0003\u0013\t\u0000\u09b7\u09b8\u0003\u0017\u000b\u0000"+ + "\u09b8\u09b9\u0003!\u0010\u0000\u09b9\u00e2\u0001\u0000\u0000\u0000\u09ba"+ + "\u09bb\u0003\u000b\u0005\u0000\u09bb\u09bc\u0003\u001d\u000e\u0000\u09bc"+ + "\u09bd\u0003#\u0011\u0000\u09bd\u09be\u0003\t\u0004\u0000\u09be\u00e4"+ + "\u0001\u0000\u0000\u0000\u09bf\u09c0\u0003\u000b\u0005\u0000\u09c0\u09c1"+ + "\u0003\u001d\u000e\u0000\u09c1\u09c2\u0003#\u0011\u0000\u09c2\u09c3\u0003"+ + "+\u0015\u0000\u09c3\u09c4\u0003\u000f\u0007\u0000\u09c4\u00e6\u0001\u0000"+ + "\u0000\u0000\u09c5\u09c6\u0003\u000b\u0005\u0000\u09c6\u09c7\u0003\u001d"+ + "\u000e\u0000\u09c7\u09c8\u0003/\u0017\u0000\u09c8\u09c9\u0003+\u0015\u0000"+ + "\u09c9\u09ca\u0003-\u0016\u0000\u09ca\u09cb\u0003\u000f\u0007\u0000\u09cb"+ + "\u09cc\u0003)\u0014\u0000\u09cc\u00e8\u0001\u0000\u0000\u0000\u09cd\u09ce"+ + "\u0003\u000b\u0005\u0000\u09ce\u09cf\u0003#\u0011\u0000\u09cf\u09d0\u0003"+ + "\u0007\u0003\u0000\u09d0\u09d1\u0003\u001d\u000e\u0000\u09d1\u09d2\u0003"+ + "\u000f\u0007\u0000\u09d2\u09d3\u0003+\u0015\u0000\u09d3\u09d4\u0003\u000b"+ + "\u0005\u0000\u09d4\u09d5\u0003\u000f\u0007\u0000\u09d5\u00ea\u0001\u0000"+ + "\u0000\u0000\u09d6\u09d7\u0003\u000b\u0005\u0000\u09d7\u09d8\u0003#\u0011"+ + "\u0000\u09d8\u09d9\u0003\t\u0004\u0000\u09d9\u09da\u0003#\u0011\u0000"+ + "\u09da\u09db\u0003\u001d\u000e\u0000\u09db\u00ec\u0001\u0000\u0000\u0000"+ + "\u09dc\u09dd\u0003\u000b\u0005\u0000\u09dd\u09de\u0003#\u0011\u0000\u09de"+ + "\u09df\u0003\u001d\u000e\u0000\u09df\u09e0\u0003\u001d\u000e\u0000\u09e0"+ + "\u09e1\u0003\u0007\u0003\u0000\u09e1\u09e2\u0003-\u0016\u0000\u09e2\u09e3"+ + "\u0003\u000f\u0007\u0000\u09e3\u00ee\u0001\u0000\u0000\u0000\u09e4\u09e5"+ + "\u0003\u000b\u0005\u0000\u09e5\u09e6\u0003#\u0011\u0000\u09e6\u09e7\u0003"+ + "\u001d\u000e\u0000\u09e7\u09e8\u0003\u001d\u000e\u0000\u09e8\u09e9\u0003"+ + "\u0007\u0003\u0000\u09e9\u09ea\u0003-\u0016\u0000\u09ea\u09eb\u0003\u0017"+ + "\u000b\u0000\u09eb\u09ec\u0003#\u0011\u0000\u09ec\u09ed\u0003!\u0010\u0000"+ + "\u09ed\u00f0\u0001\u0000\u0000\u0000\u09ee\u09ef\u0003\u000b\u0005\u0000"+ + "\u09ef\u09f0\u0003#\u0011\u0000\u09f0\u09f1\u0003\u001d\u000e\u0000\u09f1"+ + "\u09f2\u0003\u001d\u000e\u0000\u09f2\u09f3\u0003\u0007\u0003\u0000\u09f3"+ + "\u09f4\u0003-\u0016\u0000\u09f4\u09f5\u0003\u0017\u000b\u0000\u09f5\u09f6"+ + "\u0003#\u0011\u0000\u09f6\u09f7\u0003!\u0010\u0000\u09f7\u09f8\u0005_"+ + "\u0000\u0000\u09f8\u09f9\u0003\u000b\u0005\u0000\u09f9\u09fa\u0003\u0007"+ + "\u0003\u0000\u09fa\u09fb\u0003-\u0016\u0000\u09fb\u09fc\u0003\u0007\u0003"+ + "\u0000\u09fc\u09fd\u0003\u001d\u000e\u0000\u09fd\u09fe\u0003#\u0011\u0000"+ + "\u09fe\u09ff\u0003\u0013\t\u0000\u09ff\u00f2\u0001\u0000\u0000\u0000\u0a00"+ + "\u0a01\u0003\u000b\u0005\u0000\u0a01\u0a02\u0003#\u0011\u0000\u0a02\u0a03"+ + "\u0003\u001d\u000e\u0000\u0a03\u0a04\u0003\u001d\u000e\u0000\u0a04\u0a05"+ + "\u0003\u0007\u0003\u0000\u0a05\u0a06\u0003-\u0016\u0000\u0a06\u0a07\u0003"+ + "\u0017\u000b\u0000\u0a07\u0a08\u0003#\u0011\u0000\u0a08\u0a09\u0003!\u0010"+ + "\u0000\u0a09\u0a0a\u0005_\u0000\u0000\u0a0a\u0a0b\u0003!\u0010\u0000\u0a0b"+ + "\u0a0c\u0003\u0007\u0003\u0000\u0a0c\u0a0d\u0003\u001f\u000f\u0000\u0a0d"+ + "\u0a0e\u0003\u000f\u0007\u0000\u0a0e\u00f4\u0001\u0000\u0000\u0000\u0a0f"+ + "\u0a10\u0003\u000b\u0005\u0000\u0a10\u0a11\u0003#\u0011\u0000\u0a11\u0a12"+ + "\u0003\u001d\u000e\u0000\u0a12\u0a13\u0003\u001d\u000e\u0000\u0a13\u0a14"+ + "\u0003\u0007\u0003\u0000\u0a14\u0a15\u0003-\u0016\u0000\u0a15\u0a16\u0003"+ + "\u0017\u000b\u0000\u0a16\u0a17\u0003#\u0011\u0000\u0a17\u0a18\u0003!\u0010"+ + "\u0000\u0a18\u0a19\u0005_\u0000\u0000\u0a19\u0a1a\u0003+\u0015\u0000\u0a1a"+ + "\u0a1b\u0003\u000b\u0005\u0000\u0a1b\u0a1c\u0003\u0015\n\u0000\u0a1c\u0a1d"+ + "\u0003\u000f\u0007\u0000\u0a1d\u0a1e\u0003\u001f\u000f\u0000\u0a1e\u0a1f"+ + "\u0003\u0007\u0003\u0000\u0a1f\u00f6\u0001\u0000\u0000\u0000\u0a20\u0a21"+ + "\u0003\u000b\u0005\u0000\u0a21\u0a22\u0003#\u0011\u0000\u0a22\u0a23\u0003"+ + "\u001d\u000e\u0000\u0a23\u0a24\u0003\u001d\u000e\u0000\u0a24\u0a25\u0003"+ + "\u000f\u0007\u0000\u0a25\u0a26\u0003\u000b\u0005\u0000\u0a26\u0a27\u0003"+ + "-\u0016\u0000\u0a27\u00f8\u0001\u0000\u0000\u0000\u0a28\u0a29\u0003\u000b"+ + "\u0005\u0000\u0a29\u0a2a\u0003#\u0011\u0000\u0a2a\u0a2b\u0003\u001d\u000e"+ + "\u0000\u0a2b\u0a2c\u0003/\u0017\u0000\u0a2c\u0a2d\u0003\u001f\u000f\u0000"+ + "\u0a2d\u0a2e\u0003!\u0010\u0000\u0a2e\u00fa\u0001\u0000\u0000\u0000\u0a2f"+ + "\u0a30\u0003\u000b\u0005\u0000\u0a30\u0a31\u0003#\u0011\u0000\u0a31\u0a32"+ + "\u0003\u001d\u000e\u0000\u0a32\u0a33\u0003/\u0017\u0000\u0a33\u0a34\u0003"+ + "\u001f\u000f\u0000\u0a34\u0a35\u0003!\u0010\u0000\u0a35\u0a36\u0005_\u0000"+ + "\u0000\u0a36\u0a37\u0003!\u0010\u0000\u0a37\u0a38\u0003\u0007\u0003\u0000"+ + "\u0a38\u0a39\u0003\u001f\u000f\u0000\u0a39\u0a3a\u0003\u000f\u0007\u0000"+ + "\u0a3a\u00fc\u0001\u0000\u0000\u0000\u0a3b\u0a3c\u0003\u000b\u0005\u0000"+ + "\u0a3c\u0a3d\u0003#\u0011\u0000\u0a3d\u0a3e\u0003\u001f\u000f\u0000\u0a3e"+ + "\u0a3f\u0003\u001f\u000f\u0000\u0a3f\u0a40\u0003\u0007\u0003\u0000\u0a40"+ + "\u0a41\u0003!\u0010\u0000\u0a41\u0a42\u0003\r\u0006\u0000\u0a42\u0a43"+ + "\u0005_\u0000\u0000\u0a43\u0a44\u0003\u0011\b\u0000\u0a44\u0a45\u0003"+ + "/\u0017\u0000\u0a45\u0a46\u0003!\u0010\u0000\u0a46\u0a47\u0003\u000b\u0005"+ + "\u0000\u0a47\u0a48\u0003-\u0016\u0000\u0a48\u0a49\u0003\u0017\u000b\u0000"+ + "\u0a49\u0a4a\u0003#\u0011\u0000\u0a4a\u0a4b\u0003!\u0010\u0000\u0a4b\u00fe"+ + "\u0001\u0000\u0000\u0000\u0a4c\u0a4d\u0003\u000b\u0005\u0000\u0a4d\u0a4e"+ + "\u0003#\u0011\u0000\u0a4e\u0a4f\u0003\u001f\u000f\u0000\u0a4f\u0a50\u0003"+ + "\u001f\u000f\u0000\u0a50\u0a51\u0003\u0007\u0003\u0000\u0a51\u0a52\u0003"+ + "!\u0010\u0000\u0a52\u0a53\u0003\r\u0006\u0000\u0a53\u0a54\u0005_\u0000"+ + "\u0000\u0a54\u0a55\u0003\u0011\b\u0000\u0a55\u0a56\u0003/\u0017\u0000"+ + "\u0a56\u0a57\u0003!\u0010\u0000\u0a57\u0a58\u0003\u000b\u0005\u0000\u0a58"+ + "\u0a59\u0003-\u0016\u0000\u0a59\u0a5a\u0003\u0017\u000b\u0000\u0a5a\u0a5b"+ + "\u0003#\u0011\u0000\u0a5b\u0a5c\u0003!\u0010\u0000\u0a5c\u0a5d\u0005_"+ + "\u0000\u0000\u0a5d\u0a5e\u0003\u000b\u0005\u0000\u0a5e\u0a5f\u0003#\u0011"+ + "\u0000\u0a5f\u0a60\u0003\r\u0006\u0000\u0a60\u0a61\u0003\u000f\u0007\u0000"+ + "\u0a61\u0100\u0001\u0000\u0000\u0000\u0a62\u0a63\u0003\u000b\u0005\u0000"+ + "\u0a63\u0a64\u0003#\u0011\u0000\u0a64\u0a65\u0003\u001f\u000f\u0000\u0a65"+ + "\u0a66\u0003\u001f\u000f\u0000\u0a66\u0a67\u0003\u000f\u0007\u0000\u0a67"+ + "\u0a68\u0003!\u0010\u0000\u0a68\u0a69\u0003-\u0016\u0000\u0a69\u0102\u0001"+ + "\u0000\u0000\u0000\u0a6a\u0a6b\u0003\u000b\u0005\u0000\u0a6b\u0a6c\u0003"+ + "#\u0011\u0000\u0a6c\u0a6d\u0003\u001f\u000f\u0000\u0a6d\u0a6e\u0003\u001f"+ + "\u000f\u0000\u0a6e\u0a6f\u0003\u0017\u000b\u0000\u0a6f\u0a70\u0003-\u0016"+ + "\u0000\u0a70\u0104\u0001\u0000\u0000\u0000\u0a71\u0a72\u0003\u000b\u0005"+ + "\u0000\u0a72\u0a73\u0003#\u0011\u0000\u0a73\u0a74\u0003\u001f\u000f\u0000"+ + "\u0a74\u0a75\u0003\u001f\u000f\u0000\u0a75\u0a76\u0003\u0017\u000b\u0000"+ + "\u0a76\u0a77\u0003-\u0016\u0000\u0a77\u0a78\u0003-\u0016\u0000\u0a78\u0a79"+ + "\u0003\u000f\u0007\u0000\u0a79\u0a7a\u0003\r\u0006\u0000\u0a7a\u0106\u0001"+ + "\u0000\u0000\u0000\u0a7b\u0a7c\u0003\u000b\u0005\u0000\u0a7c\u0a7d\u0003"+ + "#\u0011\u0000\u0a7d\u0a7e\u0003\u001f\u000f\u0000\u0a7e\u0a7f\u0003%\u0012"+ + "\u0000\u0a7f\u0a80\u0003\u001d\u000e\u0000\u0a80\u0a81\u0003\u000f\u0007"+ + "\u0000\u0a81\u0a82\u0003-\u0016\u0000\u0a82\u0a83\u0003\u0017\u000b\u0000"+ + "\u0a83\u0a84\u0003#\u0011\u0000\u0a84\u0a85\u0003!\u0010\u0000\u0a85\u0108"+ + "\u0001\u0000\u0000\u0000\u0a86\u0a87\u0003\u000b\u0005\u0000\u0a87\u0a88"+ + "\u0003#\u0011\u0000\u0a88\u0a89\u0003!\u0010\u0000\u0a89\u0a8a\u0003\r"+ + "\u0006\u0000\u0a8a\u0a8b\u0003\u0017\u000b\u0000\u0a8b\u0a8c\u0003-\u0016"+ + "\u0000\u0a8c\u0a8d\u0003\u0017\u000b\u0000\u0a8d\u0a8e\u0003#\u0011\u0000"+ + "\u0a8e\u0a8f\u0003!\u0010\u0000\u0a8f\u010a\u0001\u0000\u0000\u0000\u0a90"+ + "\u0a91\u0003\u000b\u0005\u0000\u0a91\u0a92\u0003#\u0011\u0000\u0a92\u0a93"+ + "\u0003!\u0010\u0000\u0a93\u0a94\u0003\r\u0006\u0000\u0a94\u0a95\u0003"+ + "\u0017\u000b\u0000\u0a95\u0a96\u0003-\u0016\u0000\u0a96\u0a97\u0003\u0017"+ + "\u000b\u0000\u0a97\u0a98\u0003#\u0011\u0000\u0a98\u0a99\u0003!\u0010\u0000"+ + "\u0a99\u0a9a\u0005_\u0000\u0000\u0a9a\u0a9b\u0003!\u0010\u0000\u0a9b\u0a9c"+ + "\u0003/\u0017\u0000\u0a9c\u0a9d\u0003\u001f\u000f\u0000\u0a9d\u0a9e\u0003"+ + "\t\u0004\u0000\u0a9e\u0a9f\u0003\u000f\u0007\u0000\u0a9f\u0aa0\u0003)"+ + "\u0014\u0000\u0aa0\u010c\u0001\u0000\u0000\u0000\u0aa1\u0aa2\u0003\u000b"+ + "\u0005\u0000\u0aa2\u0aa3\u0003#\u0011\u0000\u0aa3\u0aa4\u0003!\u0010\u0000"+ + "\u0aa4\u0aa5\u0003\u0011\b\u0000\u0aa5\u0aa6\u0003\u0017\u000b\u0000\u0aa6"+ + "\u0aa7\u0003\u0013\t\u0000\u0aa7\u0aa8\u0003/\u0017\u0000\u0aa8\u0aa9"+ + "\u0003)\u0014\u0000\u0aa9\u0aaa\u0003\u0007\u0003\u0000\u0aaa\u0aab\u0003"+ + "-\u0016\u0000\u0aab\u0aac\u0003\u0017\u000b\u0000\u0aac\u0aad\u0003#\u0011"+ + "\u0000\u0aad\u0aae\u0003!\u0010\u0000\u0aae\u010e\u0001\u0000\u0000\u0000"+ + "\u0aaf\u0ab0\u0003\u000b\u0005\u0000\u0ab0\u0ab1\u0003#\u0011\u0000\u0ab1"+ + "\u0ab2\u0003!\u0010\u0000\u0ab2\u0ab3\u0003\u0011\b\u0000\u0ab3\u0ab4"+ + "\u0003\u001d\u000e\u0000\u0ab4\u0ab5\u0003\u0017\u000b\u0000\u0ab5\u0ab6"+ + "\u0003\u000b\u0005\u0000\u0ab6\u0ab7\u0003-\u0016\u0000\u0ab7\u0110\u0001"+ + "\u0000\u0000\u0000\u0ab8\u0ab9\u0003\u000b\u0005\u0000\u0ab9\u0aba\u0003"+ + "#\u0011\u0000\u0aba\u0abb\u0003!\u0010\u0000\u0abb\u0abc\u0003!\u0010"+ + "\u0000\u0abc\u0abd\u0003\u000f\u0007\u0000\u0abd\u0abe\u0003\u000b\u0005"+ + "\u0000\u0abe\u0abf\u0003-\u0016\u0000\u0abf\u0112\u0001\u0000\u0000\u0000"+ + "\u0ac0\u0ac1\u0003\u000b\u0005\u0000\u0ac1\u0ac2\u0003#\u0011\u0000\u0ac2"+ + "\u0ac3\u0003!\u0010\u0000\u0ac3\u0ac4\u0003!\u0010\u0000\u0ac4\u0ac5\u0003"+ + "\u000f\u0007\u0000\u0ac5\u0ac6\u0003\u000b\u0005\u0000\u0ac6\u0ac7\u0003"+ + "-\u0016\u0000\u0ac7\u0ac8\u0003\u0017\u000b\u0000\u0ac8\u0ac9\u0003#\u0011"+ + "\u0000\u0ac9\u0aca\u0003!\u0010\u0000\u0aca\u0114\u0001\u0000\u0000\u0000"+ + "\u0acb\u0acc\u0003\u000b\u0005\u0000\u0acc\u0acd\u0003#\u0011\u0000\u0acd"+ + "\u0ace\u0003!\u0010\u0000\u0ace\u0acf\u0003!\u0010\u0000\u0acf\u0ad0\u0003"+ + "\u000f\u0007\u0000\u0ad0\u0ad1\u0003\u000b\u0005\u0000\u0ad1\u0ad2\u0003"+ + "-\u0016\u0000\u0ad2\u0ad3\u0003\u0017\u000b\u0000\u0ad3\u0ad4\u0003#\u0011"+ + "\u0000\u0ad4\u0ad5\u0003!\u0010\u0000\u0ad5\u0ad6\u0005_\u0000\u0000\u0ad6"+ + "\u0ad7\u0003!\u0010\u0000\u0ad7\u0ad8\u0003\u0007\u0003\u0000\u0ad8\u0ad9"+ + "\u0003\u001f\u000f\u0000\u0ad9\u0ada\u0003\u000f\u0007\u0000\u0ada\u0116"+ + "\u0001\u0000\u0000\u0000\u0adb\u0adc\u0003\u000b\u0005\u0000\u0adc\u0add"+ + "\u0003#\u0011\u0000\u0add\u0ade\u0003!\u0010\u0000\u0ade\u0adf\u0003+"+ + "\u0015\u0000\u0adf\u0ae0\u0003-\u0016\u0000\u0ae0\u0ae1\u0003)\u0014\u0000"+ + "\u0ae1\u0ae2\u0003\u0007\u0003\u0000\u0ae2\u0ae3\u0003\u0017\u000b\u0000"+ + "\u0ae3\u0ae4\u0003!\u0010\u0000\u0ae4\u0ae5\u0003-\u0016\u0000\u0ae5\u0118"+ + "\u0001\u0000\u0000\u0000\u0ae6\u0ae7\u0003\u000b\u0005\u0000\u0ae7\u0ae8"+ + "\u0003#\u0011\u0000\u0ae8\u0ae9\u0003!\u0010\u0000\u0ae9\u0aea\u0003+"+ + "\u0015\u0000\u0aea\u0aeb\u0003-\u0016\u0000\u0aeb\u0aec\u0003)\u0014\u0000"+ + "\u0aec\u0aed\u0003\u0007\u0003\u0000\u0aed\u0aee\u0003\u0017\u000b\u0000"+ + "\u0aee\u0aef\u0003!\u0010\u0000\u0aef\u0af0\u0003-\u0016\u0000\u0af0\u0af1"+ + "\u0005_\u0000\u0000\u0af1\u0af2\u0003\u000b\u0005\u0000\u0af2\u0af3\u0003"+ + "\u0007\u0003\u0000\u0af3\u0af4\u0003-\u0016\u0000\u0af4\u0af5\u0003\u0007"+ + "\u0003\u0000\u0af5\u0af6\u0003\u001d\u000e\u0000\u0af6\u0af7\u0003#\u0011"+ + "\u0000\u0af7\u0af8\u0003\u0013\t\u0000\u0af8\u011a\u0001\u0000\u0000\u0000"+ + "\u0af9\u0afa\u0003\u000b\u0005\u0000\u0afa\u0afb\u0003#\u0011\u0000\u0afb"+ + "\u0afc\u0003!\u0010\u0000\u0afc\u0afd\u0003+\u0015\u0000\u0afd\u0afe\u0003"+ + "-\u0016\u0000\u0afe\u0aff\u0003)\u0014\u0000\u0aff\u0b00\u0003\u0007\u0003"+ + "\u0000\u0b00\u0b01\u0003\u0017\u000b\u0000\u0b01\u0b02\u0003!\u0010\u0000"+ + "\u0b02\u0b03\u0003-\u0016\u0000\u0b03\u0b04\u0005_\u0000\u0000\u0b04\u0b05"+ + "\u0003!\u0010\u0000\u0b05\u0b06\u0003\u0007\u0003\u0000\u0b06\u0b07\u0003"+ + "\u001f\u000f\u0000\u0b07\u0b08\u0003\u000f\u0007\u0000\u0b08\u011c\u0001"+ + "\u0000\u0000\u0000\u0b09\u0b0a\u0003\u000b\u0005\u0000\u0b0a\u0b0b\u0003"+ + "#\u0011\u0000\u0b0b\u0b0c\u0003!\u0010\u0000\u0b0c\u0b0d\u0003+\u0015"+ + "\u0000\u0b0d\u0b0e\u0003-\u0016\u0000\u0b0e\u0b0f\u0003)\u0014\u0000\u0b0f"+ + "\u0b10\u0003\u0007\u0003\u0000\u0b10\u0b11\u0003\u0017\u000b\u0000\u0b11"+ + "\u0b12\u0003!\u0010\u0000\u0b12\u0b13\u0003-\u0016\u0000\u0b13\u0b14\u0005"+ + "_\u0000\u0000\u0b14\u0b15\u0003+\u0015\u0000\u0b15\u0b16\u0003\u000b\u0005"+ + "\u0000\u0b16\u0b17\u0003\u0015\n\u0000\u0b17\u0b18\u0003\u000f\u0007\u0000"+ + "\u0b18\u0b19\u0003\u001f\u000f\u0000\u0b19\u0b1a\u0003\u0007\u0003\u0000"+ + "\u0b1a\u011e\u0001\u0000\u0000\u0000\u0b1b\u0b1c\u0003\u000b\u0005\u0000"+ + "\u0b1c\u0b1d\u0003#\u0011\u0000\u0b1d\u0b1e\u0003!\u0010\u0000\u0b1e\u0b1f"+ + "\u0003+\u0015\u0000\u0b1f\u0b20\u0003-\u0016\u0000\u0b20\u0b21\u0003)"+ + "\u0014\u0000\u0b21\u0b22\u0003\u0007\u0003\u0000\u0b22\u0b23\u0003\u0017"+ + "\u000b\u0000\u0b23\u0b24\u0003!\u0010\u0000\u0b24\u0b25\u0003-\u0016\u0000"+ + "\u0b25\u0b26\u0003+\u0015\u0000\u0b26\u0120\u0001\u0000\u0000\u0000\u0b27"+ + "\u0b28\u0003\u000b\u0005\u0000\u0b28\u0b29\u0003#\u0011\u0000\u0b29\u0b2a"+ + "\u0003!\u0010\u0000\u0b2a\u0b2b\u0003+\u0015\u0000\u0b2b\u0b2c\u0003-"+ + "\u0016\u0000\u0b2c\u0b2d\u0003)\u0014\u0000\u0b2d\u0b2e\u0003/\u0017\u0000"+ + "\u0b2e\u0b2f\u0003\u000b\u0005\u0000\u0b2f\u0b30\u0003-\u0016\u0000\u0b30"+ + "\u0b31\u0003#\u0011\u0000\u0b31\u0b32\u0003)\u0014\u0000\u0b32\u0122\u0001"+ + "\u0000\u0000\u0000\u0b33\u0b34\u0003\u000b\u0005\u0000\u0b34\u0b35\u0003"+ + "#\u0011\u0000\u0b35\u0b36\u0003!\u0010\u0000\u0b36\u0b37\u0003-\u0016"+ + "\u0000\u0b37\u0b38\u0003\u0007\u0003\u0000\u0b38\u0b39\u0003\u0017\u000b"+ + "\u0000\u0b39\u0b3a\u0003!\u0010\u0000\u0b3a\u0b3b\u0003+\u0015\u0000\u0b3b"+ + "\u0124\u0001\u0000\u0000\u0000\u0b3c\u0b3d\u0003\u000b\u0005\u0000\u0b3d"+ + "\u0b3e\u0003#\u0011\u0000\u0b3e\u0b3f\u0003!\u0010\u0000\u0b3f\u0b40\u0003"+ + "-\u0016\u0000\u0b40\u0b41\u0003\u0017\u000b\u0000\u0b41\u0b42\u0003!\u0010"+ + "\u0000\u0b42\u0b43\u0003/\u0017\u0000\u0b43\u0b44\u0003\u000f\u0007\u0000"+ + "\u0b44\u0126\u0001\u0000\u0000\u0000\u0b45\u0b46\u0003\u000b\u0005\u0000"+ + "\u0b46\u0b47\u0003#\u0011\u0000\u0b47\u0b48\u0003!\u0010\u0000\u0b48\u0b49"+ + "\u00031\u0018\u0000\u0b49\u0b4a\u0003\u000f\u0007\u0000\u0b4a\u0b4b\u0003"+ + ")\u0014\u0000\u0b4b\u0b4c\u0003+\u0015\u0000\u0b4c\u0b4d\u0003\u0017\u000b"+ + "\u0000\u0b4d\u0b4e\u0003#\u0011\u0000\u0b4e\u0b4f\u0003!\u0010\u0000\u0b4f"+ + "\u0128\u0001\u0000\u0000\u0000\u0b50\u0b51\u0003\u000b\u0005\u0000\u0b51"+ + "\u0b52\u0003#\u0011\u0000\u0b52\u0b53\u0003!\u0010\u0000\u0b53\u0b54\u0003"+ + "1\u0018\u0000\u0b54\u0b55\u0003\u000f\u0007\u0000\u0b55\u0b56\u0003)\u0014"+ + "\u0000\u0b56\u0b57\u0003-\u0016\u0000\u0b57\u012a\u0001\u0000\u0000\u0000"+ + "\u0b58\u0b59\u0003\u000b\u0005\u0000\u0b59\u0b5a\u0003#\u0011\u0000\u0b5a"+ + "\u0b5b\u0003%\u0012\u0000\u0b5b\u0b5c\u00037\u001b\u0000\u0b5c\u012c\u0001"+ + "\u0000\u0000\u0000\u0b5d\u0b5e\u0003\u000b\u0005\u0000\u0b5e\u0b5f\u0003"+ + "#\u0011\u0000\u0b5f\u0b60\u0003)\u0014\u0000\u0b60\u0b61\u0003)\u0014"+ + "\u0000\u0b61\u012e\u0001\u0000\u0000\u0000\u0b62\u0b63\u0003\u000b\u0005"+ + "\u0000\u0b63\u0b64\u0003#\u0011\u0000\u0b64\u0b65\u0003)\u0014\u0000\u0b65"+ + "\u0b66\u0003)\u0014\u0000\u0b66\u0b67\u0003\u000f\u0007\u0000\u0b67\u0b68"+ + "\u0003+\u0015\u0000\u0b68\u0b69\u0003%\u0012\u0000\u0b69\u0b6a\u0003#"+ + "\u0011\u0000\u0b6a\u0b6b\u0003!\u0010\u0000\u0b6b\u0b6c\u0003\r\u0006"+ + "\u0000\u0b6c\u0b6d\u0003\u0017\u000b\u0000\u0b6d\u0b6e\u0003!\u0010\u0000"+ + "\u0b6e\u0b6f\u0003\u0013\t\u0000\u0b6f\u0130\u0001\u0000\u0000\u0000\u0b70"+ + "\u0b71\u0003\u000b\u0005\u0000\u0b71\u0b72\u0003#\u0011\u0000\u0b72\u0b73"+ + "\u0003+\u0015\u0000\u0b73\u0b74\u0003-\u0016\u0000\u0b74\u0b75\u0003+"+ + "\u0015\u0000\u0b75\u0132\u0001\u0000\u0000\u0000\u0b76\u0b77\u0003\u000b"+ + "\u0005\u0000\u0b77\u0b78\u0003#\u0011\u0000\u0b78\u0b79\u0003/\u0017\u0000"+ + "\u0b79\u0b7a\u0003!\u0010\u0000\u0b7a\u0b7b\u0003-\u0016\u0000\u0b7b\u0134"+ + "\u0001\u0000\u0000\u0000\u0b7c\u0b7d\u0003\u000b\u0005\u0000\u0b7d\u0b7e"+ + "\u0003#\u0011\u0000\u0b7e\u0b7f\u00031\u0018\u0000\u0b7f\u0b80\u0003\u0007"+ + "\u0003\u0000\u0b80\u0b81\u0003)\u0014\u0000\u0b81\u0b82\u0005_\u0000\u0000"+ + "\u0b82\u0b83\u0003%\u0012\u0000\u0b83\u0b84\u0003#\u0011\u0000\u0b84\u0b85"+ + "\u0003%\u0012\u0000\u0b85\u0136\u0001\u0000\u0000\u0000\u0b86\u0b87\u0003"+ + "\u000b\u0005\u0000\u0b87\u0b88\u0003#\u0011\u0000\u0b88\u0b89\u00031\u0018"+ + "\u0000\u0b89\u0b8a\u0003\u0007\u0003\u0000\u0b8a\u0b8b\u0003)\u0014\u0000"+ + "\u0b8b\u0b8c\u0005_\u0000\u0000\u0b8c\u0b8d\u0003+\u0015\u0000\u0b8d\u0b8e"+ + "\u0003\u0007\u0003\u0000\u0b8e\u0b8f\u0003\u001f\u000f\u0000\u0b8f\u0b90"+ + "\u0003%\u0012\u0000\u0b90\u0138\u0001\u0000\u0000\u0000\u0b91\u0b92\u0003"+ + "\u000b\u0005\u0000\u0b92\u0b93\u0003)\u0014\u0000\u0b93\u0b94\u0003\u000f"+ + "\u0007\u0000\u0b94\u0b95\u0003\u0007\u0003\u0000\u0b95\u0b96\u0003-\u0016"+ + "\u0000\u0b96\u0b97\u0003\u000f\u0007\u0000\u0b97\u013a\u0001\u0000\u0000"+ + "\u0000\u0b98\u0b99\u0003\u000b\u0005\u0000\u0b99\u0b9a\u0003)\u0014\u0000"+ + "\u0b9a\u0b9b\u0003\u000f\u0007\u0000\u0b9b\u0b9c\u0003\u0007\u0003\u0000"+ + "\u0b9c\u0b9d\u0003-\u0016\u0000\u0b9d\u0b9e\u0003\u000f\u0007\u0000\u0b9e"+ + "\u0b9f\u0003\r\u0006\u0000\u0b9f\u0ba0\u0003\t\u0004\u0000\u0ba0\u013c"+ + "\u0001\u0000\u0000\u0000\u0ba1\u0ba2\u0003\u000b\u0005\u0000\u0ba2\u0ba3"+ + "\u0003)\u0014\u0000\u0ba3\u0ba4\u0003\u000f\u0007\u0000\u0ba4\u0ba5\u0003"+ + "\u0007\u0003\u0000\u0ba5\u0ba6\u0003-\u0016\u0000\u0ba6\u0ba7\u0003\u000f"+ + "\u0007\u0000\u0ba7\u0ba8\u0003/\u0017\u0000\u0ba8\u0ba9\u0003+\u0015\u0000"+ + "\u0ba9\u0baa\u0003\u000f\u0007\u0000\u0baa\u0bab\u0003)\u0014\u0000\u0bab"+ + "\u013e\u0001\u0000\u0000\u0000\u0bac\u0bad\u0003\u000b\u0005\u0000\u0bad"+ + "\u0bae\u0003)\u0014\u0000\u0bae\u0baf\u0003#\u0011\u0000\u0baf\u0bb0\u0003"+ + "+\u0015\u0000\u0bb0\u0bb1\u0003+\u0015\u0000\u0bb1\u0140\u0001\u0000\u0000"+ + "\u0000\u0bb2\u0bb3\u0003\u000b\u0005\u0000\u0bb3\u0bb4\u0003+\u0015\u0000"+ + "\u0bb4\u0bb5\u00031\u0018\u0000\u0bb5\u0142\u0001\u0000\u0000\u0000\u0bb6"+ + "\u0bb7\u0003\u000b\u0005\u0000\u0bb7\u0bb8\u0003/\u0017\u0000\u0bb8\u0bb9"+ + "\u0003\t\u0004\u0000\u0bb9\u0bba\u0003\u000f\u0007\u0000\u0bba\u0144\u0001"+ + "\u0000\u0000\u0000\u0bbb\u0bbc\u0003\u000b\u0005\u0000\u0bbc\u0bbd\u0003"+ + "/\u0017\u0000\u0bbd\u0bbe\u0003\u001f\u000f\u0000\u0bbe\u0bbf\u0003\u000f"+ + "\u0007\u0000\u0bbf\u0bc0\u0005_\u0000\u0000\u0bc0\u0bc1\u0003\r\u0006"+ + "\u0000\u0bc1\u0bc2\u0003\u0017\u000b\u0000\u0bc2\u0bc3\u0003+\u0015\u0000"+ + "\u0bc3\u0bc4\u0003-\u0016\u0000\u0bc4\u0146\u0001\u0000\u0000\u0000\u0bc5"+ + "\u0bc6\u0003\u000b\u0005\u0000\u0bc6\u0bc7\u0003/\u0017\u0000\u0bc7\u0bc8"+ + "\u0003)\u0014\u0000\u0bc8\u0bc9\u0003)\u0014\u0000\u0bc9\u0bca\u0003\u000f"+ + "\u0007\u0000\u0bca\u0bcb\u0003!\u0010\u0000\u0bcb\u0bcc\u0003-\u0016\u0000"+ + "\u0bcc\u0148\u0001\u0000\u0000\u0000\u0bcd\u0bce\u0003\u000b\u0005\u0000"+ + "\u0bce\u0bcf\u0003/\u0017\u0000\u0bcf\u0bd0\u0003)\u0014\u0000\u0bd0\u0bd1"+ + "\u0003)\u0014\u0000\u0bd1\u0bd2\u0003\u000f\u0007\u0000\u0bd2\u0bd3\u0003"+ + "!\u0010\u0000\u0bd3\u0bd4\u0003-\u0016\u0000\u0bd4\u0bd5\u0005_\u0000"+ + "\u0000\u0bd5\u0bd6\u0003\r\u0006\u0000\u0bd6\u0bd7\u0003\u0007\u0003\u0000"+ + "\u0bd7\u0bd8\u0003-\u0016\u0000\u0bd8\u0bd9\u0003\u000f\u0007\u0000\u0bd9"+ + "\u014a\u0001\u0000\u0000\u0000\u0bda\u0bdb\u0003\u000b\u0005\u0000\u0bdb"+ + "\u0bdc\u0003/\u0017\u0000\u0bdc\u0bdd\u0003)\u0014\u0000\u0bdd\u0bde\u0003"+ + ")\u0014\u0000\u0bde\u0bdf\u0003\u000f\u0007\u0000\u0bdf\u0be0\u0003!\u0010"+ + "\u0000\u0be0\u0be1\u0003-\u0016\u0000\u0be1\u0be2\u0005_\u0000\u0000\u0be2"+ + "\u0be3\u0003\r\u0006\u0000\u0be3\u0be4\u0003\u000f\u0007\u0000\u0be4\u0be5"+ + "\u0003\u0011\b\u0000\u0be5\u0be6\u0003\u0007\u0003\u0000\u0be6\u0be7\u0003"+ + "/\u0017\u0000\u0be7\u0be8\u0003\u001d\u000e\u0000\u0be8\u0be9\u0003-\u0016"+ + "\u0000\u0be9\u0bea\u0005_\u0000\u0000\u0bea\u0beb\u0003-\u0016\u0000\u0beb"+ + "\u0bec\u0003)\u0014\u0000\u0bec\u0bed\u0003\u0007\u0003\u0000\u0bed\u0bee"+ + "\u0003!\u0010\u0000\u0bee\u0bef\u0003+\u0015\u0000\u0bef\u0bf0\u0003\u0011"+ + "\b\u0000\u0bf0\u0bf1\u0003#\u0011\u0000\u0bf1\u0bf2\u0003)\u0014\u0000"+ + "\u0bf2\u0bf3\u0003\u001f\u000f\u0000\u0bf3\u0bf4\u0005_\u0000\u0000\u0bf4"+ + "\u0bf5\u0003\u0013\t\u0000\u0bf5\u0bf6\u0003)\u0014\u0000\u0bf6\u0bf7"+ + "\u0003#\u0011\u0000\u0bf7\u0bf8\u0003/\u0017\u0000\u0bf8\u0bf9\u0003%"+ + "\u0012\u0000\u0bf9\u014c\u0001\u0000\u0000\u0000\u0bfa\u0bfb\u0003\u000b"+ + "\u0005\u0000\u0bfb\u0bfc\u0003/\u0017\u0000\u0bfc\u0bfd\u0003)\u0014\u0000"+ + "\u0bfd\u0bfe\u0003)\u0014\u0000\u0bfe\u0bff\u0003\u000f\u0007\u0000\u0bff"+ + "\u0c00\u0003!\u0010\u0000\u0c00\u0c01\u0003-\u0016\u0000\u0c01\u0c02\u0005"+ + "_\u0000\u0000\u0c02\u0c03\u0003%\u0012\u0000\u0c03\u0c04\u0003\u0007\u0003"+ + "\u0000\u0c04\u0c05\u0003-\u0016\u0000\u0c05\u0c06\u0003\u0015\n\u0000"+ + "\u0c06\u014e\u0001\u0000\u0000\u0000\u0c07\u0c08\u0003\u000b\u0005\u0000"+ + "\u0c08\u0c09\u0003/\u0017\u0000\u0c09\u0c0a\u0003)\u0014\u0000\u0c0a\u0c0b"+ + "\u0003)\u0014\u0000\u0c0b\u0c0c\u0003\u000f\u0007\u0000\u0c0c\u0c0d\u0003"+ + "!\u0010\u0000\u0c0d\u0c0e\u0003-\u0016\u0000\u0c0e\u0c0f\u0005_\u0000"+ + "\u0000\u0c0f\u0c10\u0003)\u0014\u0000\u0c10\u0c11\u0003#\u0011\u0000\u0c11"+ + "\u0c12\u0003\u001d\u000e\u0000\u0c12\u0c13\u0003\u000f\u0007\u0000\u0c13"+ + "\u0150\u0001\u0000\u0000\u0000\u0c14\u0c15\u0003\u000b\u0005\u0000\u0c15"+ + "\u0c16\u0003/\u0017\u0000\u0c16\u0c17\u0003)\u0014\u0000\u0c17\u0c18\u0003"+ + ")\u0014\u0000\u0c18\u0c19\u0003\u000f\u0007\u0000\u0c19\u0c1a\u0003!\u0010"+ + "\u0000\u0c1a\u0c1b\u0003-\u0016\u0000\u0c1b\u0c1c\u0005_\u0000\u0000\u0c1c"+ + "\u0c1d\u0003-\u0016\u0000\u0c1d\u0c1e\u0003\u0017\u000b\u0000\u0c1e\u0c1f"+ + "\u0003\u001f\u000f\u0000\u0c1f\u0c20\u0003\u000f\u0007\u0000\u0c20\u0152"+ + "\u0001\u0000\u0000\u0000\u0c21\u0c22\u0003\u000b\u0005\u0000\u0c22\u0c23"+ + "\u0003/\u0017\u0000\u0c23\u0c24\u0003)\u0014\u0000\u0c24\u0c25\u0003)"+ + "\u0014\u0000\u0c25\u0c26\u0003\u000f\u0007\u0000\u0c26\u0c27\u0003!\u0010"+ + "\u0000\u0c27\u0c28\u0003-\u0016\u0000\u0c28\u0c29\u0005_\u0000\u0000\u0c29"+ + "\u0c2a\u0003-\u0016\u0000\u0c2a\u0c2b\u0003\u0017\u000b\u0000\u0c2b\u0c2c"+ + "\u0003\u001f\u000f\u0000\u0c2c\u0c2d\u0003\u000f\u0007\u0000\u0c2d\u0c2e"+ + "\u0003+\u0015\u0000\u0c2e\u0c2f\u0003-\u0016\u0000\u0c2f\u0c30\u0003\u0007"+ + "\u0003\u0000\u0c30\u0c31\u0003\u001f\u000f\u0000\u0c31\u0c32\u0003%\u0012"+ + "\u0000\u0c32\u0154\u0001\u0000\u0000\u0000\u0c33\u0c34\u0003\u000b\u0005"+ + "\u0000\u0c34\u0c35\u0003/\u0017\u0000\u0c35\u0c36\u0003)\u0014\u0000\u0c36"+ + "\u0c37\u0003)\u0014\u0000\u0c37\u0c38\u0003\u000f\u0007\u0000\u0c38\u0c39"+ + "\u0003!\u0010\u0000\u0c39\u0c3a\u0003-\u0016\u0000\u0c3a\u0c3b\u0005_"+ + "\u0000\u0000\u0c3b\u0c3c\u0003-\u0016\u0000\u0c3c\u0c3d\u0003)\u0014\u0000"+ + "\u0c3d\u0c3e\u0003\u0007\u0003\u0000\u0c3e\u0c3f\u0003!\u0010\u0000\u0c3f"+ + "\u0c40\u0003+\u0015\u0000\u0c40\u0c41\u0003\u0011\b\u0000\u0c41\u0c42"+ + "\u0003#\u0011\u0000\u0c42\u0c43\u0003)\u0014\u0000\u0c43\u0c44\u0003\u001f"+ + "\u000f\u0000\u0c44\u0c45\u0005_\u0000\u0000\u0c45\u0c46\u0003\u0013\t"+ + "\u0000\u0c46\u0c47\u0003)\u0014\u0000\u0c47\u0c48\u0003#\u0011\u0000\u0c48"+ + "\u0c49\u0003/\u0017\u0000\u0c49\u0c4a\u0003%\u0012\u0000\u0c4a\u0c4b\u0005"+ + "_\u0000\u0000\u0c4b\u0c4c\u0003\u0011\b\u0000\u0c4c\u0c4d\u0003#\u0011"+ + "\u0000\u0c4d\u0c4e\u0003)\u0014\u0000\u0c4e\u0c4f\u0005_\u0000\u0000\u0c4f"+ + "\u0c50\u0003-\u0016\u0000\u0c50\u0c51\u00037\u001b\u0000\u0c51\u0c52\u0003"+ + "%\u0012\u0000\u0c52\u0c53\u0003\u000f\u0007\u0000\u0c53\u0156\u0001\u0000"+ + "\u0000\u0000\u0c54\u0c55\u0003\u000b\u0005\u0000\u0c55\u0c56\u0003/\u0017"+ + "\u0000\u0c56\u0c57\u0003)\u0014\u0000\u0c57\u0c58\u0003)\u0014\u0000\u0c58"+ + "\u0c59\u0003\u000f\u0007\u0000\u0c59\u0c5a\u0003!\u0010\u0000\u0c5a\u0c5b"+ + "\u0003-\u0016\u0000\u0c5b\u0c5c\u0005_\u0000\u0000\u0c5c\u0c5d\u0003/"+ + "\u0017\u0000\u0c5d\u0c5e\u0003+\u0015\u0000\u0c5e\u0c5f\u0003\u000f\u0007"+ + "\u0000\u0c5f\u0c60\u0003)\u0014\u0000\u0c60\u0158\u0001\u0000\u0000\u0000"+ + "\u0c61\u0c62\u0003\u000b\u0005\u0000\u0c62\u0c63\u0003/\u0017\u0000\u0c63"+ + "\u0c64\u0003)\u0014\u0000\u0c64\u0c65\u0003+\u0015\u0000\u0c65\u0c66\u0003"+ + "#\u0011\u0000\u0c66\u0c67\u0003)\u0014\u0000\u0c67\u015a\u0001\u0000\u0000"+ + "\u0000\u0c68\u0c69\u0003\u000b\u0005\u0000\u0c69\u0c6a\u0003/\u0017\u0000"+ + "\u0c6a\u0c6b\u0003)\u0014\u0000\u0c6b\u0c6c\u0003+\u0015\u0000\u0c6c\u0c6d"+ + "\u0003#\u0011\u0000\u0c6d\u0c6e\u0003)\u0014\u0000\u0c6e\u0c6f\u0005_"+ + "\u0000\u0000\u0c6f\u0c70\u0003!\u0010\u0000\u0c70\u0c71\u0003\u0007\u0003"+ + "\u0000\u0c71\u0c72\u0003\u001f\u000f\u0000\u0c72\u0c73\u0003\u000f\u0007"+ + "\u0000\u0c73\u015c\u0001\u0000\u0000\u0000\u0c74\u0c75\u0003\u000b\u0005"+ + "\u0000\u0c75\u0c76\u00037\u001b\u0000\u0c76\u0c77\u0003\u000b\u0005\u0000"+ + "\u0c77\u0c78\u0003\u001d\u000e\u0000\u0c78\u0c79\u0003\u000f\u0007\u0000"+ + "\u0c79\u015e\u0001\u0000\u0000\u0000\u0c7a\u0c7b\u0003\r\u0006\u0000\u0c7b"+ + "\u0c7c\u0003\u0007\u0003\u0000\u0c7c\u0c7d\u0003-\u0016\u0000\u0c7d\u0c7e"+ + "\u0003\u0007\u0003\u0000\u0c7e\u0160\u0001\u0000\u0000\u0000\u0c7f\u0c80"+ + "\u0003\r\u0006\u0000\u0c80\u0c81\u0003\u0007\u0003\u0000\u0c81\u0c82\u0003"+ + "-\u0016\u0000\u0c82\u0c83\u0003\u0007\u0003\u0000\u0c83\u0c84\u0003\t"+ + "\u0004\u0000\u0c84\u0c85\u0003\u0007\u0003\u0000\u0c85\u0c86\u0003+\u0015"+ + "\u0000\u0c86\u0c87\u0003\u000f\u0007\u0000\u0c87\u0162\u0001\u0000\u0000"+ + "\u0000\u0c88\u0c89\u0003\r\u0006\u0000\u0c89\u0c8a\u0003\u0007\u0003\u0000"+ + "\u0c8a\u0c8b\u0003-\u0016\u0000\u0c8b\u0c8c\u0003\u000f\u0007\u0000\u0c8c"+ + "\u0164\u0001\u0000\u0000\u0000\u0c8d\u0c8e\u0003\r\u0006\u0000\u0c8e\u0c8f"+ + "\u0003\u0007\u0003\u0000\u0c8f\u0c90\u0003-\u0016\u0000\u0c90\u0c91\u0003"+ + "\u000f\u0007\u0000\u0c91\u0c92\u0003-\u0016\u0000\u0c92\u0c93\u0003\u0017"+ + "\u000b\u0000\u0c93\u0c94\u0003\u001f\u000f\u0000\u0c94\u0c95\u0003\u000f"+ + "\u0007\u0000\u0c95\u0c96\u0005_\u0000\u0000\u0c96\u0c97\u0003\u0017\u000b"+ + "\u0000\u0c97\u0c98\u0003!\u0010\u0000\u0c98\u0c99\u0003-\u0016\u0000\u0c99"+ + "\u0c9a\u0003\u000f\u0007\u0000\u0c9a\u0c9b\u0003)\u0014\u0000\u0c9b\u0c9c"+ + "\u00031\u0018\u0000\u0c9c\u0c9d\u0003\u0007\u0003\u0000\u0c9d\u0c9e\u0003"+ + "\u001d\u000e\u0000\u0c9e\u0c9f\u0005_\u0000\u0000\u0c9f\u0ca0\u0003\u000b"+ + "\u0005\u0000\u0ca0\u0ca1\u0003#\u0011\u0000\u0ca1\u0ca2\u0003\r\u0006"+ + "\u0000\u0ca2\u0ca3\u0003\u000f\u0007\u0000\u0ca3\u0166\u0001\u0000\u0000"+ + "\u0000\u0ca4\u0ca5\u0003\r\u0006\u0000\u0ca5\u0ca6\u0003\u0007\u0003\u0000"+ + "\u0ca6\u0ca7\u0003-\u0016\u0000\u0ca7\u0ca8\u0003\u000f\u0007\u0000\u0ca8"+ + "\u0ca9\u0003-\u0016\u0000\u0ca9\u0caa\u0003\u0017\u000b\u0000\u0caa\u0cab"+ + "\u0003\u001f\u000f\u0000\u0cab\u0cac\u0003\u000f\u0007\u0000\u0cac\u0cad"+ + "\u0005_\u0000\u0000\u0cad\u0cae\u0003\u0017\u000b\u0000\u0cae\u0caf\u0003"+ + "!\u0010\u0000\u0caf\u0cb0\u0003-\u0016\u0000\u0cb0\u0cb1\u0003\u000f\u0007"+ + "\u0000\u0cb1\u0cb2\u0003)\u0014\u0000\u0cb2\u0cb3\u00031\u0018\u0000\u0cb3"+ + "\u0cb4\u0003\u0007\u0003\u0000\u0cb4\u0cb5\u0003\u001d\u000e\u0000\u0cb5"+ + "\u0cb6\u0005_\u0000\u0000\u0cb6\u0cb7\u0003%\u0012\u0000\u0cb7\u0cb8\u0003"+ + ")\u0014\u0000\u0cb8\u0cb9\u0003\u000f\u0007\u0000\u0cb9\u0cba\u0003\u000b"+ + "\u0005\u0000\u0cba\u0cbb\u0003\u0017\u000b\u0000\u0cbb\u0cbc\u0003+\u0015"+ + "\u0000\u0cbc\u0cbd\u0003\u0017\u000b\u0000\u0cbd\u0cbe\u0003#\u0011\u0000"+ + "\u0cbe\u0cbf\u0003!\u0010\u0000\u0cbf\u0168\u0001\u0000\u0000\u0000\u0cc0"+ + "\u0cc1\u0003\r\u0006\u0000\u0cc1\u0cc2\u0003\u0007\u0003\u0000\u0cc2\u0cc3"+ + "\u00037\u001b\u0000\u0cc3\u016a\u0001\u0000\u0000\u0000\u0cc4\u0cc5\u0003"+ + "\r\u0006\u0000\u0cc5\u0cc6\u0003\u000f\u0007\u0000\u0cc6\u0cc7\u0003\u0007"+ + "\u0003\u0000\u0cc7\u0cc8\u0003\u001d\u000e\u0000\u0cc8\u0cc9\u0003\u001d"+ + "\u000e\u0000\u0cc9\u0cca\u0003#\u0011\u0000\u0cca\u0ccb\u0003\u000b\u0005"+ + "\u0000\u0ccb\u0ccc\u0003\u0007\u0003\u0000\u0ccc\u0ccd\u0003-\u0016\u0000"+ + "\u0ccd\u0cce\u0003\u000f\u0007\u0000\u0cce\u016c\u0001\u0000\u0000\u0000"+ + "\u0ccf\u0cd0\u0003\r\u0006\u0000\u0cd0\u0cd1\u0003\u000f\u0007\u0000\u0cd1"+ + "\u0cd2\u0003\u000b\u0005\u0000\u0cd2\u016e\u0001\u0000\u0000\u0000\u0cd3"+ + "\u0cd4\u0003\r\u0006\u0000\u0cd4\u0cd5\u0003\u000f\u0007\u0000\u0cd5\u0cd6"+ + "\u0003\u000b\u0005\u0000\u0cd6\u0cd7\u0003\u0017\u000b\u0000\u0cd7\u0cd8"+ + "\u0003\u001f\u000f\u0000\u0cd8\u0cd9\u0003\u0007\u0003\u0000\u0cd9\u0cda"+ + "\u0003\u001d\u000e\u0000\u0cda\u0170\u0001\u0000\u0000\u0000\u0cdb\u0cdc"+ + "\u0003\r\u0006\u0000\u0cdc\u0cdd\u0003\u000f\u0007\u0000\u0cdd\u0cde\u0003"+ + "\u000b\u0005\u0000\u0cde\u0cdf\u0003\u001d\u000e\u0000\u0cdf\u0ce0\u0003"+ + "\u0007\u0003\u0000\u0ce0\u0ce1\u0003)\u0014\u0000\u0ce1\u0ce2\u0003\u000f"+ + "\u0007\u0000\u0ce2\u0172\u0001\u0000\u0000\u0000\u0ce3\u0ce4\u0003\r\u0006"+ + "\u0000\u0ce4\u0ce5\u0003\u000f\u0007\u0000\u0ce5\u0ce6\u0003\u0011\b\u0000"+ + "\u0ce6\u0ce7\u0003\u0007\u0003\u0000\u0ce7\u0ce8\u0003/\u0017\u0000\u0ce8"+ + "\u0ce9\u0003\u001d\u000e\u0000\u0ce9\u0cea\u0003-\u0016\u0000\u0cea\u0174"+ + "\u0001\u0000\u0000\u0000\u0ceb\u0cec\u0003\r\u0006\u0000\u0cec\u0ced\u0003"+ + "\u000f\u0007\u0000\u0ced\u0cee\u0003\u0011\b\u0000\u0cee\u0cef\u0003\u0007"+ + "\u0003\u0000\u0cef\u0cf0\u0003/\u0017\u0000\u0cf0\u0cf1\u0003\u001d\u000e"+ + "\u0000\u0cf1\u0cf2\u0003-\u0016\u0000\u0cf2\u0cf3\u0003+\u0015\u0000\u0cf3"+ + "\u0176\u0001\u0000\u0000\u0000\u0cf4\u0cf5\u0003\r\u0006\u0000\u0cf5\u0cf6"+ + "\u0003\u000f\u0007\u0000\u0cf6\u0cf7\u0003\u0011\b\u0000\u0cf7\u0cf8\u0003"+ + "\u000f\u0007\u0000\u0cf8\u0cf9\u0003)\u0014\u0000\u0cf9\u0cfa\u0003\u0007"+ + "\u0003\u0000\u0cfa\u0cfb\u0003\t\u0004\u0000\u0cfb\u0cfc\u0003\u001d\u000e"+ + "\u0000\u0cfc\u0cfd\u0003\u000f\u0007\u0000\u0cfd\u0178\u0001\u0000\u0000"+ + "\u0000\u0cfe\u0cff\u0003\r\u0006\u0000\u0cff\u0d00\u0003\u000f\u0007\u0000"+ + "\u0d00\u0d01\u0003\u0011\b\u0000\u0d01\u0d02\u0003\u000f\u0007\u0000\u0d02"+ + "\u0d03\u0003)\u0014\u0000\u0d03\u0d04\u0003)\u0014\u0000\u0d04\u0d05\u0003"+ + "\u0007\u0003\u0000\u0d05\u0d06\u0003\t\u0004\u0000\u0d06\u0d07\u0003\u001d"+ + "\u000e\u0000\u0d07\u0d08\u0003\u000f\u0007\u0000\u0d08\u017a\u0001\u0000"+ + "\u0000\u0000\u0d09\u0d0a\u0003\r\u0006\u0000\u0d0a\u0d0b\u0003\u000f\u0007"+ + "\u0000\u0d0b\u0d0c\u0003\u0011\b\u0000\u0d0c\u0d0d\u0003\u000f\u0007\u0000"+ + "\u0d0d\u0d0e\u0003)\u0014\u0000\u0d0e\u0d0f\u0003)\u0014\u0000\u0d0f\u0d10"+ + "\u0003\u000f\u0007\u0000\u0d10\u0d11\u0003\r\u0006\u0000\u0d11\u017c\u0001"+ + "\u0000\u0000\u0000\u0d12\u0d13\u0003\r\u0006\u0000\u0d13\u0d14\u0003\u000f"+ + "\u0007\u0000\u0d14\u0d15\u0003\u0011\b\u0000\u0d15\u0d16\u0003\u0017\u000b"+ + "\u0000\u0d16\u0d17\u0003!\u0010\u0000\u0d17\u0d18\u0003\u000f\u0007\u0000"+ + "\u0d18\u0d19\u0003\r\u0006\u0000\u0d19\u017e\u0001\u0000\u0000\u0000\u0d1a"+ + "\u0d1b\u0003\r\u0006\u0000\u0d1b\u0d1c\u0003\u000f\u0007\u0000\u0d1c\u0d1d"+ + "\u0003\u0011\b\u0000\u0d1d\u0d1e\u0003\u0017\u000b\u0000\u0d1e\u0d1f\u0003"+ + "!\u0010\u0000\u0d1f\u0d20\u0003\u000f\u0007\u0000\u0d20\u0d21\u0003)\u0014"+ + "\u0000\u0d21\u0180\u0001\u0000\u0000\u0000\u0d22\u0d23\u0003\r\u0006\u0000"+ + "\u0d23\u0d24\u0003\u000f\u0007\u0000\u0d24\u0d25\u0003\u0013\t\u0000\u0d25"+ + "\u0d26\u0003)\u0014\u0000\u0d26\u0d27\u0003\u000f\u0007\u0000\u0d27\u0d28"+ + "\u0003\u000f\u0007\u0000\u0d28\u0182\u0001\u0000\u0000\u0000\u0d29\u0d2a"+ + "\u0003\r\u0006\u0000\u0d2a\u0d2b\u0003\u000f\u0007\u0000\u0d2b\u0d2c\u0003"+ + "\u001d\u000e\u0000\u0d2c\u0d2d\u0003\u000f\u0007\u0000\u0d2d\u0d2e\u0003"+ + "-\u0016\u0000\u0d2e\u0d2f\u0003\u000f\u0007\u0000\u0d2f\u0184\u0001\u0000"+ + "\u0000\u0000\u0d30\u0d31\u0003\r\u0006\u0000\u0d31\u0d32\u0003\u000f\u0007"+ + "\u0000\u0d32\u0d33\u0003\u001d\u000e\u0000\u0d33\u0d34\u0003\u0017\u000b"+ + "\u0000\u0d34\u0d35\u0003\u001f\u000f\u0000\u0d35\u0d36\u0003\u0017\u000b"+ + "\u0000\u0d36\u0d37\u0003-\u0016\u0000\u0d37\u0d38\u0003\u000f\u0007\u0000"+ + "\u0d38\u0d39\u0003)\u0014\u0000\u0d39\u0186\u0001\u0000\u0000\u0000\u0d3a"+ + "\u0d3b\u0003\r\u0006\u0000\u0d3b\u0d3c\u0003\u000f\u0007\u0000\u0d3c\u0d3d"+ + "\u0003\u001d\u000e\u0000\u0d3d\u0d3e\u0003\u0017\u000b\u0000\u0d3e\u0d3f"+ + "\u0003\u001f\u000f\u0000\u0d3f\u0d40\u0003\u0017\u000b\u0000\u0d40\u0d41"+ + "\u0003-\u0016\u0000\u0d41\u0d42\u0003\u000f\u0007\u0000\u0d42\u0d43\u0003"+ + ")\u0014\u0000\u0d43\u0d44\u0003+\u0015\u0000\u0d44\u0188\u0001\u0000\u0000"+ + "\u0000\u0d45\u0d46\u0003\r\u0006\u0000\u0d46\u0d47\u0003\u000f\u0007\u0000"+ + "\u0d47\u0d48\u0003!\u0010\u0000\u0d48\u0d49\u0003+\u0015\u0000\u0d49\u0d4a"+ + "\u0003\u000f\u0007\u0000\u0d4a\u0d4b\u0005_\u0000\u0000\u0d4b\u0d4c\u0003"+ + ")\u0014\u0000\u0d4c\u0d4d\u0003\u0007\u0003\u0000\u0d4d\u0d4e\u0003!\u0010"+ + "\u0000\u0d4e\u0d4f\u0003\u001b\r\u0000\u0d4f\u018a\u0001\u0000\u0000\u0000"+ + "\u0d50\u0d51\u0003\r\u0006\u0000\u0d51\u0d52\u0003\u000f\u0007\u0000\u0d52"+ + "\u0d53\u0003%\u0012\u0000\u0d53\u0d54\u0003\u000f\u0007\u0000\u0d54\u0d55"+ + "\u0003!\u0010\u0000\u0d55\u0d56\u0003\r\u0006\u0000\u0d56\u0d57\u0003"+ + "+\u0015\u0000\u0d57\u018c\u0001\u0000\u0000\u0000\u0d58\u0d59\u0003\r"+ + "\u0006\u0000\u0d59\u0d5a\u0003\u000f\u0007\u0000\u0d5a\u0d5b\u0003%\u0012"+ + "\u0000\u0d5b\u0d5c\u0003-\u0016\u0000\u0d5c\u0d5d\u0003\u0015\n\u0000"+ + "\u0d5d\u018e\u0001\u0000\u0000\u0000\u0d5e\u0d5f\u0003\r\u0006\u0000\u0d5f"+ + "\u0d60\u0003\u000f\u0007\u0000\u0d60\u0d61\u0003)\u0014\u0000\u0d61\u0d62"+ + "\u0003\u000f\u0007\u0000\u0d62\u0d63\u0003\u0011\b\u0000\u0d63\u0190\u0001"+ + "\u0000\u0000\u0000\u0d64\u0d65\u0003\r\u0006\u0000\u0d65\u0d66\u0003\u000f"+ + "\u0007\u0000\u0d66\u0d67\u0003)\u0014\u0000\u0d67\u0d68\u0003\u0017\u000b"+ + "\u0000\u0d68\u0d69\u00031\u0018\u0000\u0d69\u0d6a\u0003\u000f\u0007\u0000"+ + "\u0d6a\u0d6b\u0003\r\u0006\u0000\u0d6b\u0192\u0001\u0000\u0000\u0000\u0d6c"+ + "\u0d6d\u0003\r\u0006\u0000\u0d6d\u0d6e\u0003\u000f\u0007\u0000\u0d6e\u0d6f"+ + "\u0003+\u0015\u0000\u0d6f\u0d70\u0003\u000b\u0005\u0000\u0d70\u0194\u0001"+ + "\u0000\u0000\u0000\u0d71\u0d72\u0003\r\u0006\u0000\u0d72\u0d73\u0003\u000f"+ + "\u0007\u0000\u0d73\u0d74\u0003+\u0015\u0000\u0d74\u0d75\u0003\u000b\u0005"+ + "\u0000\u0d75\u0d76\u0003)\u0014\u0000\u0d76\u0d77\u0003\u0017\u000b\u0000"+ + "\u0d77\u0d78\u0003\t\u0004\u0000\u0d78\u0d79\u0003\u000f\u0007\u0000\u0d79"+ + "\u0196\u0001\u0000\u0000\u0000\u0d7a\u0d7b\u0003\r\u0006\u0000\u0d7b\u0d7c"+ + "\u0003\u000f\u0007\u0000\u0d7c\u0d7d\u0003+\u0015\u0000\u0d7d\u0d7e\u0003"+ + "\u000b\u0005\u0000\u0d7e\u0d7f\u0003)\u0014\u0000\u0d7f\u0d80\u0003\u0017"+ + "\u000b\u0000\u0d80\u0d81\u0003%\u0012\u0000\u0d81\u0d82\u0003-\u0016\u0000"+ + "\u0d82\u0d83\u0003#\u0011\u0000\u0d83\u0d84\u0003)\u0014\u0000\u0d84\u0198"+ + "\u0001\u0000\u0000\u0000\u0d85\u0d86\u0003\r\u0006\u0000\u0d86\u0d87\u0003"+ + "\u000f\u0007\u0000\u0d87\u0d88\u0003+\u0015\u0000\u0d88\u0d89\u0003-\u0016"+ + "\u0000\u0d89\u0d8a\u0003)\u0014\u0000\u0d8a\u0d8b\u0003#\u0011\u0000\u0d8b"+ + "\u0d8c\u00037\u001b\u0000\u0d8c\u019a\u0001\u0000\u0000\u0000\u0d8d\u0d8e"+ + "\u0003\r\u0006\u0000\u0d8e\u0d8f\u0003\u000f\u0007\u0000\u0d8f\u0d90\u0003"+ + "+\u0015\u0000\u0d90\u0d91\u0003-\u0016\u0000\u0d91\u0d92\u0003)\u0014"+ + "\u0000\u0d92\u0d93\u0003/\u0017\u0000\u0d93\u0d94\u0003\u000b\u0005\u0000"+ + "\u0d94\u0d95\u0003-\u0016\u0000\u0d95\u0d96\u0003#\u0011\u0000\u0d96\u0d97"+ + "\u0003)\u0014\u0000\u0d97\u019c\u0001\u0000\u0000\u0000\u0d98\u0d99\u0003"+ + "\r\u0006\u0000\u0d99\u0d9a\u0003\u000f\u0007\u0000\u0d9a\u0d9b\u0003-"+ + "\u0016\u0000\u0d9b\u0d9c\u0003\u000f\u0007\u0000\u0d9c\u0d9d\u0003)\u0014"+ + "\u0000\u0d9d\u0d9e\u0003\u001f\u000f\u0000\u0d9e\u0d9f\u0003\u0017\u000b"+ + "\u0000\u0d9f\u0da0\u0003!\u0010\u0000\u0da0\u0da1\u0003\u0017\u000b\u0000"+ + "\u0da1\u0da2\u0003+\u0015\u0000\u0da2\u0da3\u0003-\u0016\u0000\u0da3\u0da4"+ + "\u0003\u0017\u000b\u0000\u0da4\u0da5\u0003\u000b\u0005\u0000\u0da5\u019e"+ + "\u0001\u0000\u0000\u0000\u0da6\u0da7\u0003\r\u0006\u0000\u0da7\u0da8\u0003"+ + "\u0017\u000b\u0000\u0da8\u0da9\u0003\u0007\u0003\u0000\u0da9\u0daa\u0003"+ + "\u0013\t\u0000\u0daa\u0dab\u0003!\u0010\u0000\u0dab\u0dac\u0003#\u0011"+ + "\u0000\u0dac\u0dad\u0003+\u0015\u0000\u0dad\u0dae\u0003-\u0016\u0000\u0dae"+ + "\u0daf\u0003\u0017\u000b\u0000\u0daf\u0db0\u0003\u000b\u0005\u0000\u0db0"+ + "\u0db1\u0003+\u0015\u0000\u0db1\u01a0\u0001\u0000\u0000\u0000\u0db2\u0db3"+ + "\u0003\r\u0006\u0000\u0db3\u0db4\u0003\u0017\u000b\u0000\u0db4\u0db5\u0003"+ + "\u000b\u0005\u0000\u0db5\u0db6\u0003-\u0016\u0000\u0db6\u0db7\u0003\u0017"+ + "\u000b\u0000\u0db7\u0db8\u0003#\u0011\u0000\u0db8\u0db9\u0003!\u0010\u0000"+ + "\u0db9\u0dba\u0003\u0007\u0003\u0000\u0dba\u0dbb\u0003)\u0014\u0000\u0dbb"+ + "\u0dbc\u00037\u001b\u0000\u0dbc\u01a2\u0001\u0000\u0000\u0000\u0dbd\u0dbe"+ + "\u0003\r\u0006\u0000\u0dbe\u0dbf\u0003\u0017\u000b\u0000\u0dbf\u0dc0\u0003"+ + "+\u0015\u0000\u0dc0\u0dc1\u0003\u0007\u0003\u0000\u0dc1\u0dc2\u0003\t"+ + "\u0004\u0000\u0dc2\u0dc3\u0003\u001d\u000e\u0000\u0dc3\u0dc4\u0003\u000f"+ + "\u0007\u0000\u0dc4\u01a4\u0001\u0000\u0000\u0000\u0dc5\u0dc6\u0003\r\u0006"+ + "\u0000\u0dc6\u0dc7\u0003\u0017\u000b\u0000\u0dc7\u0dc8\u0003+\u0015\u0000"+ + "\u0dc8\u0dc9\u0003\u0007\u0003\u0000\u0dc9\u0dca\u0003\t\u0004\u0000\u0dca"+ + "\u0dcb\u0003\u001d\u000e\u0000\u0dcb\u0dcc\u0003\u000f\u0007\u0000\u0dcc"+ + "\u0dcd\u0005_\u0000\u0000\u0dcd\u0dce\u0003%\u0012\u0000\u0dce\u0dcf\u0003"+ + "\u0007\u0003\u0000\u0dcf\u0dd0\u0003\u0013\t\u0000\u0dd0\u0dd1\u0003\u000f"+ + "\u0007\u0000\u0dd1\u0dd2\u0005_\u0000\u0000\u0dd2\u0dd3\u0003+\u0015\u0000"+ + "\u0dd3\u0dd4\u0003\u001b\r\u0000\u0dd4\u0dd5\u0003\u0017\u000b\u0000\u0dd5"+ + "\u0dd6\u0003%\u0012\u0000\u0dd6\u0dd7\u0003%\u0012\u0000\u0dd7\u0dd8\u0003"+ + "\u0017\u000b\u0000\u0dd8\u0dd9\u0003!\u0010\u0000\u0dd9\u0dda\u0003\u0013"+ + "\t\u0000\u0dda\u01a6\u0001\u0000\u0000\u0000\u0ddb\u0ddc\u0003\r\u0006"+ + "\u0000\u0ddc\u0ddd\u0003\u0017\u000b\u0000\u0ddd\u0dde\u0003+\u0015\u0000"+ + "\u0dde\u0ddf\u0003\u000b\u0005\u0000\u0ddf\u0de0\u0003\u0007\u0003\u0000"+ + "\u0de0\u0de1\u0003)\u0014\u0000\u0de1\u0de2\u0003\r\u0006\u0000\u0de2"+ + "\u01a8\u0001\u0000\u0000\u0000\u0de3\u0de4\u0003\r\u0006\u0000\u0de4\u0de5"+ + "\u0003\u0017\u000b\u0000\u0de5\u0de6\u0003+\u0015\u0000\u0de6\u0de7\u0003"+ + "\u000b\u0005\u0000\u0de7\u0de8\u0003#\u0011\u0000\u0de8\u0de9\u0003!\u0010"+ + "\u0000\u0de9\u0dea\u0003!\u0010\u0000\u0dea\u0deb\u0003\u000f\u0007\u0000"+ + "\u0deb\u0dec\u0003\u000b\u0005\u0000\u0dec\u0ded\u0003-\u0016\u0000\u0ded"+ + "\u01aa\u0001\u0000\u0000\u0000\u0dee\u0def\u0003\r\u0006\u0000\u0def\u0df0"+ + "\u0003\u0017\u000b\u0000\u0df0\u0df1\u0003+\u0015\u0000\u0df1\u0df2\u0003"+ + "%\u0012\u0000\u0df2\u0df3\u0003\u0007\u0003\u0000\u0df3\u0df4\u0003-\u0016"+ + "\u0000\u0df4\u0df5\u0003\u000b\u0005\u0000\u0df5\u0df6\u0003\u0015\n\u0000"+ + "\u0df6\u01ac\u0001\u0000\u0000\u0000\u0df7\u0df8\u0003\r\u0006\u0000\u0df8"+ + "\u0df9\u0003\u0017\u000b\u0000\u0df9\u0dfa\u0003+\u0015\u0000\u0dfa\u0dfb"+ + "\u0003-\u0016\u0000\u0dfb\u0dfc\u0003\u0017\u000b\u0000\u0dfc\u0dfd\u0003"+ + "!\u0010\u0000\u0dfd\u0dfe\u0003\u000b\u0005\u0000\u0dfe\u0dff\u0003-\u0016"+ + "\u0000\u0dff\u01ae\u0001\u0000\u0000\u0000\u0e00\u0e01\u0003\r\u0006\u0000"+ + "\u0e01\u0e02\u0003#\u0011\u0000\u0e02\u01b0\u0001\u0000\u0000\u0000\u0e03"+ + "\u0e04\u0003\r\u0006\u0000\u0e04\u0e05\u0003#\u0011\u0000\u0e05\u0e06"+ + "\u0003\u001f\u000f\u0000\u0e06\u0e07\u0003\u0007\u0003\u0000\u0e07\u0e08"+ + "\u0003\u0017\u000b\u0000\u0e08\u0e09\u0003!\u0010\u0000\u0e09\u01b2\u0001"+ + "\u0000\u0000\u0000\u0e0a\u0e0b\u0003\r\u0006\u0000\u0e0b\u0e0c\u0003#"+ + "\u0011\u0000\u0e0c\u0e0d\u0003/\u0017\u0000\u0e0d\u0e0e\u0003\t\u0004"+ + "\u0000\u0e0e\u0e0f\u0003\u001d\u000e\u0000\u0e0f\u0e10\u0003\u000f\u0007"+ + "\u0000\u0e10\u01b4\u0001\u0000\u0000\u0000\u0e11\u0e12\u0003\r\u0006\u0000"+ + "\u0e12\u0e13\u0003)\u0014\u0000\u0e13\u0e14\u0003#\u0011\u0000\u0e14\u0e15"+ + "\u0003%\u0012\u0000\u0e15\u01b6\u0001\u0000\u0000\u0000\u0e16\u0e17\u0003"+ + "\r\u0006\u0000\u0e17\u0e18\u00037\u001b\u0000\u0e18\u0e19\u0003!\u0010"+ + "\u0000\u0e19\u0e1a\u0003\u0007\u0003\u0000\u0e1a\u0e1b\u0003\u001f\u000f"+ + "\u0000\u0e1b\u0e1c\u0003\u0017\u000b\u0000\u0e1c\u0e1d\u0003\u000b\u0005"+ + "\u0000\u0e1d\u01b8\u0001\u0000\u0000\u0000\u0e1e\u0e1f\u0003\r\u0006\u0000"+ + "\u0e1f\u0e20\u00037\u001b\u0000\u0e20\u0e21\u0003!\u0010\u0000\u0e21\u0e22"+ + "\u0003\u0007\u0003\u0000\u0e22\u0e23\u0003\u001f\u000f\u0000\u0e23\u0e24"+ + "\u0003\u0017\u000b\u0000\u0e24\u0e25\u0003\u000b\u0005\u0000\u0e25\u0e26"+ + "\u0005_\u0000\u0000\u0e26\u0e27\u0003\u0011\b\u0000\u0e27\u0e28\u0003"+ + "/\u0017\u0000\u0e28\u0e29\u0003!\u0010\u0000\u0e29\u0e2a\u0003\u000b\u0005"+ + "\u0000\u0e2a\u0e2b\u0003-\u0016\u0000\u0e2b\u0e2c\u0003\u0017\u000b\u0000"+ + "\u0e2c\u0e2d\u0003#\u0011\u0000\u0e2d\u0e2e\u0003!\u0010\u0000\u0e2e\u01ba"+ + "\u0001\u0000\u0000\u0000\u0e2f\u0e30\u0003\r\u0006\u0000\u0e30\u0e31\u0003"+ + "7\u001b\u0000\u0e31\u0e32\u0003!\u0010\u0000\u0e32\u0e33\u0003\u0007\u0003"+ + "\u0000\u0e33\u0e34\u0003\u001f\u000f\u0000\u0e34\u0e35\u0003\u0017\u000b"+ + "\u0000\u0e35\u0e36\u0003\u000b\u0005\u0000\u0e36\u0e37\u0005_\u0000\u0000"+ + "\u0e37\u0e38\u0003\u0011\b\u0000\u0e38\u0e39\u0003/\u0017\u0000\u0e39"+ + "\u0e3a\u0003!\u0010\u0000\u0e3a\u0e3b\u0003\u000b\u0005\u0000\u0e3b\u0e3c"+ + "\u0003-\u0016\u0000\u0e3c\u0e3d\u0003\u0017\u000b\u0000\u0e3d\u0e3e\u0003"+ + "#\u0011\u0000\u0e3e\u0e3f\u0003!\u0010\u0000\u0e3f\u0e40\u0005_\u0000"+ + "\u0000\u0e40\u0e41\u0003\u000b\u0005\u0000\u0e41\u0e42\u0003#\u0011\u0000"+ + "\u0e42\u0e43\u0003\r\u0006\u0000\u0e43\u0e44\u0003\u000f\u0007\u0000\u0e44"+ + "\u01bc\u0001\u0000\u0000\u0000\u0e45\u0e46\u0003\u000f\u0007\u0000\u0e46"+ + "\u0e47\u0003\u0007\u0003\u0000\u0e47\u0e48\u0003\u000b\u0005\u0000\u0e48"+ + "\u0e49\u0003\u0015\n\u0000\u0e49\u01be\u0001\u0000\u0000\u0000\u0e4a\u0e4b"+ + "\u0003\u000f\u0007\u0000\u0e4b\u0e4c\u0003\u001d\u000e\u0000\u0e4c\u0e4d"+ + "\u0003\u000f\u0007\u0000\u0e4d\u0e4e\u0003\u001f\u000f\u0000\u0e4e\u0e4f"+ + "\u0003\u000f\u0007\u0000\u0e4f\u0e50\u0003!\u0010\u0000\u0e50\u0e51\u0003"+ + "-\u0016\u0000\u0e51\u01c0\u0001\u0000\u0000\u0000\u0e52\u0e53\u0003\u000f"+ + "\u0007\u0000\u0e53\u0e54\u0003\u001d\u000e\u0000\u0e54\u0e55\u0003+\u0015"+ + "\u0000\u0e55\u0e56\u0003\u000f\u0007\u0000\u0e56\u01c2\u0001\u0000\u0000"+ + "\u0000\u0e57\u0e58\u0003\u000f\u0007\u0000\u0e58\u0e59\u0003!\u0010\u0000"+ + "\u0e59\u0e5a\u0003\u0007\u0003\u0000\u0e5a\u0e5b\u0003\t\u0004\u0000\u0e5b"+ + "\u0e5c\u0003\u001d\u000e\u0000\u0e5c\u0e5d\u0003\u000f\u0007\u0000\u0e5d"+ + "\u01c4\u0001\u0000\u0000\u0000\u0e5e\u0e5f\u0003\u000f\u0007\u0000\u0e5f"+ + "\u0e60\u0003!\u0010\u0000\u0e60\u0e61\u0003\u000b\u0005\u0000\u0e61\u0e62"+ + "\u0003#\u0011\u0000\u0e62\u0e63\u0003\r\u0006\u0000\u0e63\u0e64\u0003"+ + "\u0017\u000b\u0000\u0e64\u0e65\u0003!\u0010\u0000\u0e65\u0e66\u0003\u0013"+ + "\t\u0000\u0e66\u01c6\u0001\u0000\u0000\u0000\u0e67\u0e68\u0003\u000f\u0007"+ + "\u0000\u0e68\u0e69\u0003!\u0010\u0000\u0e69\u0e6a\u0003\u000b\u0005\u0000"+ + "\u0e6a\u0e6b\u0003)\u0014\u0000\u0e6b\u0e6c\u00037\u001b\u0000\u0e6c\u0e6d"+ + "\u0003%\u0012\u0000\u0e6d\u0e6e\u0003-\u0016\u0000\u0e6e\u0e6f\u0003\u000f"+ + "\u0007\u0000\u0e6f\u0e70\u0003\r\u0006\u0000\u0e70\u01c8\u0001\u0000\u0000"+ + "\u0000\u0e71\u0e72\u0003\u000f\u0007\u0000\u0e72\u0e73\u0003!\u0010\u0000"+ + "\u0e73\u0e74\u0003\r\u0006\u0000\u0e74\u01ca\u0001\u0000\u0000\u0000\u0e75"+ + "\u0e76\u0003\u000f\u0007\u0000\u0e76\u0e77\u0003!\u0010\u0000\u0e77\u0e78"+ + "\u0003\r\u0006\u0000\u0e78\u0e79\u0005-\u0000\u0000\u0e79\u0e7a\u0003"+ + "\u000f\u0007\u0000\u0e7a\u0e7b\u00035\u001a\u0000\u0e7b\u0e7c\u0003\u000f"+ + "\u0007\u0000\u0e7c\u0e7d\u0003\u000b\u0005\u0000\u0e7d\u01cc\u0001\u0000"+ + "\u0000\u0000\u0e7e\u0e7f\u0003\u000f\u0007\u0000\u0e7f\u0e80\u0003\'\u0013"+ + "\u0000\u0e80\u0e81\u0003/\u0017\u0000\u0e81\u0e82\u0003\u0007\u0003\u0000"+ + "\u0e82\u0e83\u0003\u001d\u000e\u0000\u0e83\u0e84\u0003+\u0015\u0000\u0e84"+ + "\u01ce\u0001\u0000\u0000\u0000\u0e85\u0e86\u0003\u000f\u0007\u0000\u0e86"+ + "\u0e87\u0003+\u0015\u0000\u0e87\u0e88\u0003\u000b\u0005\u0000\u0e88\u0e89"+ + "\u0003\u0007\u0003\u0000\u0e89\u0e8a\u0003%\u0012\u0000\u0e8a\u0e8b\u0003"+ + "\u000f\u0007\u0000\u0e8b\u01d0\u0001\u0000\u0000\u0000\u0e8c\u0e8d\u0003"+ + "\u000f\u0007\u0000\u0e8d\u0e8e\u00031\u0018\u0000\u0e8e\u0e8f\u0003\u000f"+ + "\u0007\u0000\u0e8f\u0e90\u0003)\u0014\u0000\u0e90\u0e91\u00037\u001b\u0000"+ + "\u0e91\u01d2\u0001\u0000\u0000\u0000\u0e92\u0e93\u0003\u000f\u0007\u0000"+ + "\u0e93\u0e94\u00035\u001a\u0000\u0e94\u0e95\u0003\u000b\u0005\u0000\u0e95"+ + "\u0e96\u0003\u000f\u0007\u0000\u0e96\u0e97\u0003%\u0012\u0000\u0e97\u0e98"+ + "\u0003-\u0016\u0000\u0e98\u01d4\u0001\u0000\u0000\u0000\u0e99\u0e9a\u0003"+ + "\u000f\u0007\u0000\u0e9a\u0e9b\u00035\u001a\u0000\u0e9b\u0e9c\u0003\u000b"+ + "\u0005\u0000\u0e9c\u0e9d\u0003\u000f\u0007\u0000\u0e9d\u0e9e\u0003%\u0012"+ + "\u0000\u0e9e\u0e9f\u0003-\u0016\u0000\u0e9f\u0ea0\u0003\u0017\u000b\u0000"+ + "\u0ea0\u0ea1\u0003#\u0011\u0000\u0ea1\u0ea2\u0003!\u0010\u0000\u0ea2\u01d6"+ + "\u0001\u0000\u0000\u0000\u0ea3\u0ea4\u0003\u000f\u0007\u0000\u0ea4\u0ea5"+ + "\u00035\u001a\u0000\u0ea5\u0ea6\u0003\u000b\u0005\u0000\u0ea6\u0ea7\u0003"+ + "\u001d\u000e\u0000\u0ea7\u0ea8\u0003/\u0017\u0000\u0ea8\u0ea9\u0003\r"+ + "\u0006\u0000\u0ea9\u0eaa\u0003\u000f\u0007\u0000\u0eaa\u01d8\u0001\u0000"+ + "\u0000\u0000\u0eab\u0eac\u0003\u000f\u0007\u0000\u0eac\u0ead\u00035\u001a"+ + "\u0000\u0ead\u0eae\u0003\u000b\u0005\u0000\u0eae\u0eaf\u0003\u001d\u000e"+ + "\u0000\u0eaf\u0eb0\u0003/\u0017\u0000\u0eb0\u0eb1\u0003\r\u0006\u0000"+ + "\u0eb1\u0eb2\u0003\u0017\u000b\u0000\u0eb2\u0eb3\u0003!\u0010\u0000\u0eb3"+ + "\u0eb4\u0003\u0013\t\u0000\u0eb4\u01da\u0001\u0000\u0000\u0000\u0eb5\u0eb6"+ + "\u0003\u000f\u0007\u0000\u0eb6\u0eb7\u00035\u001a\u0000\u0eb7\u0eb8\u0003"+ + "\u000b\u0005\u0000\u0eb8\u0eb9\u0003\u001d\u000e\u0000\u0eb9\u0eba\u0003"+ + "/\u0017\u0000\u0eba\u0ebb\u0003+\u0015\u0000\u0ebb\u0ebc\u0003\u0017\u000b"+ + "\u0000\u0ebc\u0ebd\u00031\u0018\u0000\u0ebd\u0ebe\u0003\u000f\u0007\u0000"+ + "\u0ebe\u01dc\u0001\u0000\u0000\u0000\u0ebf\u0ec0\u0003\u000f\u0007\u0000"+ + "\u0ec0\u0ec1\u00035\u001a\u0000\u0ec1\u0ec2\u0003\u000f\u0007\u0000\u0ec2"+ + "\u0ec3\u0003\u000b\u0005\u0000\u0ec3\u01de\u0001\u0000\u0000\u0000\u0ec4"+ + "\u0ec5\u0003\u000f\u0007\u0000\u0ec5\u0ec6\u00035\u001a\u0000\u0ec6\u0ec7"+ + "\u0003\u000f\u0007\u0000\u0ec7\u0ec8\u0003\u000b\u0005\u0000\u0ec8\u0ec9"+ + "\u0003/\u0017\u0000\u0ec9\u0eca\u0003-\u0016\u0000\u0eca\u0ecb\u0003\u000f"+ + "\u0007\u0000\u0ecb\u01e0\u0001\u0000\u0000\u0000\u0ecc\u0ecd\u0003\u000f"+ + "\u0007\u0000\u0ecd\u0ece\u00035\u001a\u0000\u0ece\u0ecf\u0003\u0017\u000b"+ + "\u0000\u0ecf\u0ed0\u0003+\u0015\u0000\u0ed0\u0ed1\u0003-\u0016\u0000\u0ed1"+ + "\u0ed2\u0003\u0017\u000b\u0000\u0ed2\u0ed3\u0003!\u0010\u0000\u0ed3\u0ed4"+ + "\u0003\u0013\t\u0000\u0ed4\u01e2\u0001\u0000\u0000\u0000\u0ed5\u0ed6\u0003"+ + "\u000f\u0007\u0000\u0ed6\u0ed7\u00035\u001a\u0000\u0ed7\u0ed8\u0003\u0017"+ + "\u000b\u0000\u0ed8\u0ed9\u0003+\u0015\u0000\u0ed9\u0eda\u0003-\u0016\u0000"+ + "\u0eda\u0edb\u0003+\u0015\u0000\u0edb\u01e4\u0001\u0000\u0000\u0000\u0edc"+ + "\u0edd\u0003\u000f\u0007\u0000\u0edd\u0ede\u00035\u001a\u0000\u0ede\u0edf"+ + "\u0003%\u0012\u0000\u0edf\u01e6\u0001\u0000\u0000\u0000\u0ee0\u0ee1\u0003"+ + "\u000f\u0007\u0000\u0ee1\u0ee2\u00035\u001a\u0000\u0ee2\u0ee3\u0003%\u0012"+ + "\u0000\u0ee3\u0ee4\u0003\u001d\u000e\u0000\u0ee4\u0ee5\u0003\u0007\u0003"+ + "\u0000\u0ee5\u0ee6\u0003\u0017\u000b\u0000\u0ee6\u0ee7\u0003!\u0010\u0000"+ + "\u0ee7\u01e8\u0001\u0000\u0000\u0000\u0ee8\u0ee9\u0003\u000f\u0007\u0000"+ + "\u0ee9\u0eea\u00035\u001a\u0000\u0eea\u0eeb\u0003-\u0016\u0000\u0eeb\u0eec"+ + "\u0003\u000f\u0007\u0000\u0eec\u0eed\u0003!\u0010\u0000\u0eed\u0eee\u0003"+ + "\r\u0006\u0000\u0eee\u0eef\u0003\u000f\u0007\u0000\u0eef\u0ef0\u0003\r"+ + "\u0006\u0000\u0ef0\u01ea\u0001\u0000\u0000\u0000\u0ef1\u0ef2\u0003\u000f"+ + "\u0007\u0000\u0ef2\u0ef3\u00035\u001a\u0000\u0ef3\u0ef4\u0003-\u0016\u0000"+ + "\u0ef4\u0ef5\u0003\u000f\u0007\u0000\u0ef5\u0ef6\u0003!\u0010\u0000\u0ef6"+ + "\u0ef7\u0003+\u0015\u0000\u0ef7\u0ef8\u0003\u0017\u000b\u0000\u0ef8\u0ef9"+ + "\u0003#\u0011\u0000\u0ef9\u0efa\u0003!\u0010\u0000\u0efa\u01ec\u0001\u0000"+ + "\u0000\u0000\u0efb\u0efc\u0003\u000f\u0007\u0000\u0efc\u0efd\u00035\u001a"+ + "\u0000\u0efd\u0efe\u0003-\u0016\u0000\u0efe\u0eff\u0003\u000f\u0007\u0000"+ + "\u0eff\u0f00\u0003)\u0014\u0000\u0f00\u0f01\u0003!\u0010\u0000\u0f01\u0f02"+ + "\u0003\u0007\u0003\u0000\u0f02\u0f03\u0003\u001d\u000e\u0000\u0f03\u01ee"+ + "\u0001\u0000\u0000\u0000\u0f04\u0f05\u0003\u000f\u0007\u0000\u0f05\u0f06"+ + "\u00035\u001a\u0000\u0f06\u0f07\u0003-\u0016\u0000\u0f07\u0f08\u0003)"+ + "\u0014\u0000\u0f08\u0f09\u0003\u0007\u0003\u0000\u0f09\u0f0a\u0003\u000b"+ + "\u0005\u0000\u0f0a\u0f0b\u0003-\u0016\u0000\u0f0b\u01f0\u0001\u0000\u0000"+ + "\u0000\u0f0c\u0f0d\u0003\u0011\b\u0000\u0f0d\u0f0e\u0003\u0007\u0003\u0000"+ + "\u0f0e\u0f0f\u0003\u001d\u000e\u0000\u0f0f\u0f10\u0003+\u0015\u0000\u0f10"+ + "\u0f11\u0003\u000f\u0007\u0000\u0f11\u01f2\u0001\u0000\u0000\u0000\u0f12"+ + "\u0f13\u0003\u0011\b\u0000\u0f13\u0f14\u0003\u000f\u0007\u0000\u0f14\u0f15"+ + "\u0003-\u0016\u0000\u0f15\u0f16\u0003\u000b\u0005\u0000\u0f16\u0f17\u0003"+ + "\u0015\n\u0000\u0f17\u01f4\u0001\u0000\u0000\u0000\u0f18\u0f19\u0003\u0011"+ + "\b\u0000\u0f19\u0f1a\u0003\u0017\u000b\u0000\u0f1a\u0f1b\u0003\u000f\u0007"+ + "\u0000\u0f1b\u0f1c\u0003\u001d\u000e\u0000\u0f1c\u0f1d\u0003\r\u0006\u0000"+ + "\u0f1d\u0f1e\u0003+\u0015\u0000\u0f1e\u01f6\u0001\u0000\u0000\u0000\u0f1f"+ + "\u0f20\u0003\u0011\b\u0000\u0f20\u0f21\u0003\u0017\u000b\u0000\u0f21\u0f22"+ + "\u0003\u001d\u000e\u0000\u0f22\u0f23\u0003-\u0016\u0000\u0f23\u0f24\u0003"+ + "\u000f\u0007\u0000\u0f24\u0f25\u0003)\u0014\u0000\u0f25\u01f8\u0001\u0000"+ + "\u0000\u0000\u0f26\u0f27\u0003\u0011\b\u0000\u0f27\u0f28\u0003\u0017\u000b"+ + "\u0000\u0f28\u0f29\u0003!\u0010\u0000\u0f29\u0f2a\u0003\u0007\u0003\u0000"+ + "\u0f2a\u0f2b\u0003\u001d\u000e\u0000\u0f2b\u01fa\u0001\u0000\u0000\u0000"+ + "\u0f2c\u0f2d\u0003\u0011\b\u0000\u0f2d\u0f2e\u0003\u0017\u000b\u0000\u0f2e"+ + "\u0f2f\u0003)\u0014\u0000\u0f2f\u0f30\u0003+\u0015\u0000\u0f30\u0f31\u0003"+ + "-\u0016\u0000\u0f31\u01fc\u0001\u0000\u0000\u0000\u0f32\u0f33\u0003\u0011"+ + "\b\u0000\u0f33\u0f34\u0003\u001d\u000e\u0000\u0f34\u0f35\u0003#\u0011"+ + "\u0000\u0f35\u0f36\u0003\u0007\u0003\u0000\u0f36\u0f37\u0003-\u0016\u0000"+ + "\u0f37\u01fe\u0001\u0000\u0000\u0000\u0f38\u0f39\u0003\u0011\b\u0000\u0f39"+ + "\u0f3a\u0003\u001d\u000e\u0000\u0f3a\u0f3b\u0003#\u0011\u0000\u0f3b\u0f3c"+ + "\u0003#\u0011\u0000\u0f3c\u0f3d\u0003)\u0014\u0000\u0f3d\u0200\u0001\u0000"+ + "\u0000\u0000\u0f3e\u0f3f\u0003\u0011\b\u0000\u0f3f\u0f40\u0003#\u0011"+ + "\u0000\u0f40\u0f41\u0003\u001d\u000e\u0000\u0f41\u0f42\u0003\u001d\u000e"+ + "\u0000\u0f42\u0f43\u0003#\u0011\u0000\u0f43\u0f44\u00033\u0019\u0000\u0f44"+ + "\u0f45\u0003\u0017\u000b\u0000\u0f45\u0f46\u0003!\u0010\u0000\u0f46\u0f47"+ + "\u0003\u0013\t\u0000\u0f47\u0202\u0001\u0000\u0000\u0000\u0f48\u0f49\u0003"+ + "\u0011\b\u0000\u0f49\u0f4a\u0003#\u0011\u0000\u0f4a\u0f4b\u0003)\u0014"+ + "\u0000\u0f4b\u0204\u0001\u0000\u0000\u0000\u0f4c\u0f4d\u0003\u0011\b\u0000"+ + "\u0f4d\u0f4e\u0003#\u0011\u0000\u0f4e\u0f4f\u0003)\u0014\u0000\u0f4f\u0f50"+ + "\u0003\u000b\u0005\u0000\u0f50\u0f51\u0003\u000f\u0007\u0000\u0f51\u0206"+ + "\u0001\u0000\u0000\u0000\u0f52\u0f53\u0003\u0011\b\u0000\u0f53\u0f54\u0003"+ + "#\u0011\u0000\u0f54\u0f55\u0003)\u0014\u0000\u0f55\u0f56\u0003\u000f\u0007"+ + "\u0000\u0f56\u0f57\u0003\u0017\u000b\u0000\u0f57\u0f58\u0003\u0013\t\u0000"+ + "\u0f58\u0f59\u0003!\u0010\u0000\u0f59\u0208\u0001\u0000\u0000\u0000\u0f5a"+ + "\u0f5b\u0003\u0011\b\u0000\u0f5b\u0f5c\u0003#\u0011\u0000\u0f5c\u0f5d"+ + "\u0003)\u0014\u0000\u0f5d\u0f5e\u0003\u001f\u000f\u0000\u0f5e\u0f5f\u0003"+ + "\u0007\u0003\u0000\u0f5f\u0f60\u0003-\u0016\u0000\u0f60\u020a\u0001\u0000"+ + "\u0000\u0000\u0f61\u0f62\u0003\u0011\b\u0000\u0f62\u0f63\u0003#\u0011"+ + "\u0000\u0f63\u0f64\u0003)\u0014\u0000\u0f64\u0f65\u0003-\u0016\u0000\u0f65"+ + "\u0f66\u0003)\u0014\u0000\u0f66\u0f67\u0003\u0007\u0003\u0000\u0f67\u0f68"+ + "\u0003!\u0010\u0000\u0f68\u020c\u0001\u0000\u0000\u0000\u0f69\u0f6a\u0003"+ + "\u0011\b\u0000\u0f6a\u0f6b\u0003#\u0011\u0000\u0f6b\u0f6c\u0003)\u0014"+ + "\u0000\u0f6c\u0f6d\u00033\u0019\u0000\u0f6d\u0f6e\u0003\u0007\u0003\u0000"+ + "\u0f6e\u0f6f\u0003)\u0014\u0000\u0f6f\u0f70\u0003\r\u0006\u0000\u0f70"+ + "\u020e\u0001\u0000\u0000\u0000\u0f71\u0f72\u0003\u0011\b\u0000\u0f72\u0f73"+ + "\u0003#\u0011\u0000\u0f73\u0f74\u0003/\u0017\u0000\u0f74\u0f75\u0003!"+ + "\u0010\u0000\u0f75\u0f76\u0003\r\u0006\u0000\u0f76\u0210\u0001\u0000\u0000"+ + "\u0000\u0f77\u0f78\u0003\u0011\b\u0000\u0f78\u0f79\u0003)\u0014\u0000"+ + "\u0f79\u0f7a\u0003\u000f\u0007\u0000\u0f7a\u0f7b\u0003\u000f\u0007\u0000"+ + "\u0f7b\u0212\u0001\u0000\u0000\u0000\u0f7c\u0f7d\u0003\u0011\b\u0000\u0f7d"+ + "\u0f7e\u0003)\u0014\u0000\u0f7e\u0f7f\u0003\u000f\u0007\u0000\u0f7f\u0f80"+ + "\u0003\u000f\u0007\u0000\u0f80\u0f81\u00039\u001c\u0000\u0f81\u0f82\u0003"+ + "\u000f\u0007\u0000\u0f82\u0214\u0001\u0000\u0000\u0000\u0f83\u0f84\u0003"+ + "\u0011\b\u0000\u0f84\u0f85\u0003)\u0014\u0000\u0f85\u0f86\u0003#\u0011"+ + "\u0000\u0f86\u0f87\u0003\u001f\u000f\u0000\u0f87\u0216\u0001\u0000\u0000"+ + "\u0000\u0f88\u0f89\u0003\u0011\b\u0000\u0f89\u0f8a\u0003/\u0017\u0000"+ + "\u0f8a\u0f8b\u0003\u001d\u000e\u0000\u0f8b\u0f8c\u0003\u001d\u000e\u0000"+ + "\u0f8c\u0218\u0001\u0000\u0000\u0000\u0f8d\u0f8e\u0003\u0011\b\u0000\u0f8e"+ + "\u0f8f\u0003/\u0017\u0000\u0f8f\u0f90\u0003!\u0010\u0000\u0f90\u0f91\u0003"+ + "\u000b\u0005\u0000\u0f91\u0f92\u0003-\u0016\u0000\u0f92\u0f93\u0003\u0017"+ + "\u000b\u0000\u0f93\u0f94\u0003#\u0011\u0000\u0f94\u0f95\u0003!\u0010\u0000"+ + "\u0f95\u021a\u0001\u0000\u0000\u0000\u0f96\u0f97\u0003\u0011\b\u0000\u0f97"+ + "\u0f98\u0003/\u0017\u0000\u0f98\u0f99\u0003+\u0015\u0000\u0f99\u0f9a\u0003"+ + "\u0017\u000b\u0000\u0f9a\u0f9b\u0003#\u0011\u0000\u0f9b\u0f9c\u0003!\u0010"+ + "\u0000\u0f9c\u021c\u0001\u0000\u0000\u0000\u0f9d\u0f9e\u0003\u0013\t\u0000"+ + "\u0f9e\u021e\u0001\u0000\u0000\u0000\u0f9f\u0fa0\u0003\u0013\t\u0000\u0fa0"+ + "\u0fa1\u0003\u000f\u0007\u0000\u0fa1\u0fa2\u0003!\u0010\u0000\u0fa2\u0fa3"+ + "\u0003\u000f\u0007\u0000\u0fa3\u0fa4\u0003)\u0014\u0000\u0fa4\u0fa5\u0003"+ + "\u0007\u0003\u0000\u0fa5\u0fa6\u0003\u001d\u000e\u0000\u0fa6\u0220\u0001"+ + "\u0000\u0000\u0000\u0fa7\u0fa8\u0003\u0013\t\u0000\u0fa8\u0fa9\u0003\u000f"+ + "\u0007\u0000\u0fa9\u0faa\u0003!\u0010\u0000\u0faa\u0fab\u0003\u000f\u0007"+ + "\u0000\u0fab\u0fac\u0003)\u0014\u0000\u0fac\u0fad\u0003\u0007\u0003\u0000"+ + "\u0fad\u0fae\u0003-\u0016\u0000\u0fae\u0faf\u0003\u000f\u0007\u0000\u0faf"+ + "\u0fb0\u0003\r\u0006\u0000\u0fb0\u0222\u0001\u0000\u0000\u0000\u0fb1\u0fb2"+ + "\u0003\u0013\t\u0000\u0fb2\u0fb3\u0003\u000f\u0007\u0000\u0fb3\u0fb4\u0003"+ + "-\u0016\u0000\u0fb4\u0224\u0001\u0000\u0000\u0000\u0fb5\u0fb6\u0003\u0013"+ + "\t\u0000\u0fb6\u0fb7\u0003\u001d\u000e\u0000\u0fb7\u0fb8\u0003#\u0011"+ + "\u0000\u0fb8\u0fb9\u0003\t\u0004\u0000\u0fb9\u0fba\u0003\u0007\u0003\u0000"+ + "\u0fba\u0fbb\u0003\u001d\u000e\u0000\u0fbb\u0226\u0001\u0000\u0000\u0000"+ + "\u0fbc\u0fbd\u0003\u0013\t\u0000\u0fbd\u0fbe\u0003#\u0011\u0000\u0fbe"+ + "\u0228\u0001\u0000\u0000\u0000\u0fbf\u0fc0\u0003\u0013\t\u0000\u0fc0\u0fc1"+ + "\u0003#\u0011\u0000\u0fc1\u0fc2\u0003-\u0016\u0000\u0fc2\u0fc3\u0003#"+ + "\u0011\u0000\u0fc3\u022a\u0001\u0000\u0000\u0000\u0fc4\u0fc5\u0003\u0013"+ + "\t\u0000\u0fc5\u0fc6\u0003)\u0014\u0000\u0fc6\u0fc7\u0003\u0007\u0003"+ + "\u0000\u0fc7\u0fc8\u0003!\u0010\u0000\u0fc8\u0fc9\u0003-\u0016\u0000\u0fc9"+ + "\u022c\u0001\u0000\u0000\u0000\u0fca\u0fcb\u0003\u0013\t\u0000\u0fcb\u0fcc"+ + "\u0003)\u0014\u0000\u0fcc\u0fcd\u0003\u0007\u0003\u0000\u0fcd\u0fce\u0003"+ + "!\u0010\u0000\u0fce\u0fcf\u0003-\u0016\u0000\u0fcf\u0fd0\u0003\u000f\u0007"+ + "\u0000\u0fd0\u0fd1\u0003\r\u0006\u0000\u0fd1\u022e\u0001\u0000\u0000\u0000"+ + "\u0fd2\u0fd3\u0003\u0013\t\u0000\u0fd3\u0fd4\u0003)\u0014\u0000\u0fd4"+ + "\u0fd5\u0003\u000f\u0007\u0000\u0fd5\u0fd6\u0003\u0007\u0003\u0000\u0fd6"+ + "\u0fd7\u0003-\u0016\u0000\u0fd7\u0fd8\u0003\u000f\u0007\u0000\u0fd8\u0fd9"+ + "\u0003+\u0015\u0000\u0fd9\u0fda\u0003-\u0016\u0000\u0fda\u0230\u0001\u0000"+ + "\u0000\u0000\u0fdb\u0fdc\u0003\u0013\t\u0000\u0fdc\u0fdd\u0003)\u0014"+ + "\u0000\u0fdd\u0fde\u0003#\u0011\u0000\u0fde\u0fdf\u0003/\u0017\u0000\u0fdf"+ + "\u0fe0\u0003"; + private static final String _serializedATNSegment2 = + "%\u0012\u0000\u0fe0\u0232\u0001\u0000\u0000\u0000\u0fe1\u0fe2\u0003\u0013"+ + "\t\u0000\u0fe2\u0fe3\u0003)\u0014\u0000\u0fe3\u0fe4\u0003#\u0011\u0000"+ + "\u0fe4\u0fe5\u0003/\u0017\u0000\u0fe5\u0fe6\u0003%\u0012\u0000\u0fe6\u0fe7"+ + "\u0003\u0017\u000b\u0000\u0fe7\u0fe8\u0003!\u0010\u0000\u0fe8\u0fe9\u0003"+ + "\u0013\t\u0000\u0fe9\u0234\u0001\u0000\u0000\u0000\u0fea\u0feb\u0003\u0015"+ + "\n\u0000\u0feb\u0fec\u0003\u0007\u0003\u0000\u0fec\u0fed\u0003!\u0010"+ + "\u0000\u0fed\u0fee\u0003\r\u0006\u0000\u0fee\u0fef\u0003\u001d\u000e\u0000"+ + "\u0fef\u0ff0\u0003\u000f\u0007\u0000\u0ff0\u0ff1\u0003)\u0014\u0000\u0ff1"+ + "\u0236\u0001\u0000\u0000\u0000\u0ff2\u0ff3\u0003\u0015\n\u0000\u0ff3\u0ff4"+ + "\u0003\u0007\u0003\u0000\u0ff4\u0ff5\u00031\u0018\u0000\u0ff5\u0ff6\u0003"+ + "\u0017\u000b\u0000\u0ff6\u0ff7\u0003!\u0010\u0000\u0ff7\u0ff8\u0003\u0013"+ + "\t\u0000\u0ff8\u0238\u0001\u0000\u0000\u0000\u0ff9\u0ffa\u0003\u0015\n"+ + "\u0000\u0ffa\u0ffb\u0003\u0017\u000b\u0000\u0ffb\u0ffc\u0003\u000f\u0007"+ + "\u0000\u0ffc\u0ffd\u0003)\u0014\u0000\u0ffd\u0ffe\u0003\u0007\u0003\u0000"+ + "\u0ffe\u0fff\u0003)\u0014\u0000\u0fff\u1000\u0003\u000b\u0005\u0000\u1000"+ + "\u1001\u0003\u0015\n\u0000\u1001\u1002\u00037\u001b\u0000\u1002\u023a"+ + "\u0001\u0000\u0000\u0000\u1003\u1004\u0003\u0015\n\u0000\u1004\u1005\u0003"+ + "#\u0011\u0000\u1005\u1006\u0003\u001d\u000e\u0000\u1006\u1007\u0003\r"+ + "\u0006\u0000\u1007\u023c\u0001\u0000\u0000\u0000\u1008\u1009\u0003\u0015"+ + "\n\u0000\u1009\u100a\u0003#\u0011\u0000\u100a\u100b\u0003+\u0015\u0000"+ + "\u100b\u100c\u0003-\u0016\u0000\u100c\u023e\u0001\u0000\u0000\u0000\u100d"+ + "\u100e\u0003\u0015\n\u0000\u100e\u100f\u0003#\u0011\u0000\u100f\u1010"+ + "\u0003/\u0017\u0000\u1010\u1011\u0003)\u0014\u0000\u1011\u0240\u0001\u0000"+ + "\u0000\u0000\u1012\u1013\u0003\u0017\u000b\u0000\u1013\u1014\u0003\r\u0006"+ + "\u0000\u1014\u1015\u0003\u000f\u0007\u0000\u1015\u1016\u0003!\u0010\u0000"+ + "\u1016\u1017\u0003-\u0016\u0000\u1017\u1018\u0003\u0017\u000b\u0000\u1018"+ + "\u1019\u0003-\u0016\u0000\u1019\u101a\u00037\u001b\u0000\u101a\u0242\u0001"+ + "\u0000\u0000\u0000\u101b\u101c\u0003\u0017\u000b\u0000\u101c\u101d\u0003"+ + "\u0013\t\u0000\u101d\u101e\u0003!\u0010\u0000\u101e\u101f\u0003#\u0011"+ + "\u0000\u101f\u1020\u0003)\u0014\u0000\u1020\u1021\u0003\u000f\u0007\u0000"+ + "\u1021\u0244\u0001\u0000\u0000\u0000\u1022\u1023\u0003\u0017\u000b\u0000"+ + "\u1023\u1024\u0003\u001d\u000e\u0000\u1024\u1025\u0003\u0017\u000b\u0000"+ + "\u1025\u1026\u0003\u001b\r\u0000\u1026\u1027\u0003\u000f\u0007\u0000\u1027"+ + "\u0246\u0001\u0000\u0000\u0000\u1028\u1029\u0003\u0017\u000b\u0000\u1029"+ + "\u102a\u0003\u001f\u000f\u0000\u102a\u102b\u0003\u001f\u000f\u0000\u102b"+ + "\u102c\u0003\u000f\u0007\u0000\u102c\u102d\u0003\r\u0006\u0000\u102d\u102e"+ + "\u0003\u0017\u000b\u0000\u102e\u102f\u0003\u0007\u0003\u0000\u102f\u1030"+ + "\u0003-\u0016\u0000\u1030\u1031\u0003\u000f\u0007\u0000\u1031\u0248\u0001"+ + "\u0000\u0000\u0000\u1032\u1033\u0003\u0017\u000b\u0000\u1033\u1034\u0003"+ + "\u001f\u000f\u0000\u1034\u1035\u0003\u001f\u000f\u0000\u1035\u1036\u0003"+ + "/\u0017\u0000\u1036\u1037\u0003-\u0016\u0000\u1037\u1038\u0003\u0007\u0003"+ + "\u0000\u1038\u1039\u0003\t\u0004\u0000\u1039\u103a\u0003\u001d\u000e\u0000"+ + "\u103a\u103b\u0003\u000f\u0007\u0000\u103b\u024a\u0001\u0000\u0000\u0000"+ + "\u103c\u103d\u0003\u0017\u000b\u0000\u103d\u103e\u0003\u001f\u000f\u0000"+ + "\u103e\u103f\u0003%\u0012\u0000\u103f\u1040\u0003\u001d\u000e\u0000\u1040"+ + "\u1041\u0003\u000f\u0007\u0000\u1041\u1042\u0003\u001f\u000f\u0000\u1042"+ + "\u1043\u0003\u000f\u0007\u0000\u1043\u1044\u0003!\u0010\u0000\u1044\u1045"+ + "\u0003-\u0016\u0000\u1045\u1046\u0003\u0007\u0003\u0000\u1046\u1047\u0003"+ + "-\u0016\u0000\u1047\u1048\u0003\u0017\u000b\u0000\u1048\u1049\u0003#\u0011"+ + "\u0000\u1049\u104a\u0003!\u0010\u0000\u104a\u024c\u0001\u0000\u0000\u0000"+ + "\u104b\u104c\u0003\u0017\u000b\u0000\u104c\u104d\u0003\u001f\u000f\u0000"+ + "\u104d\u104e\u0003%\u0012\u0000\u104e\u104f\u0003\u001d\u000e\u0000\u104f"+ + "\u1050\u0003\u0017\u000b\u0000\u1050\u1051\u0003\u000b\u0005\u0000\u1051"+ + "\u1052\u0003\u0017\u000b\u0000\u1052\u1053\u0003-\u0016\u0000\u1053\u024e"+ + "\u0001\u0000\u0000\u0000\u1054\u1055\u0003\u0017\u000b\u0000\u1055\u1056"+ + "\u0003!\u0010\u0000\u1056\u0250\u0001\u0000\u0000\u0000\u1057\u1058\u0003"+ + "\u0017\u000b\u0000\u1058\u1059\u0003!\u0010\u0000\u1059\u105a\u0003\u000b"+ + "\u0005\u0000\u105a\u105b\u0003\u001d\u000e\u0000\u105b\u105c\u0003/\u0017"+ + "\u0000\u105c\u105d\u0003\r\u0006\u0000\u105d\u105e\u0003\u0017\u000b\u0000"+ + "\u105e\u105f\u0003!\u0010\u0000\u105f\u1060\u0003\u0013\t\u0000\u1060"+ + "\u0252\u0001\u0000\u0000\u0000\u1061\u1062\u0003\u0017\u000b\u0000\u1062"+ + "\u1063\u0003!\u0010\u0000\u1063\u1064\u0003\u000b\u0005\u0000\u1064\u1065"+ + "\u0003)\u0014\u0000\u1065\u1066\u0003\u000f\u0007\u0000\u1066\u1067\u0003"+ + "\u001f\u000f\u0000\u1067\u1068\u0003\u000f\u0007\u0000\u1068\u1069\u0003"+ + "!\u0010\u0000\u1069\u106a\u0003-\u0016\u0000\u106a\u0254\u0001\u0000\u0000"+ + "\u0000\u106b\u106c\u0003\u0017\u000b\u0000\u106c\u106d\u0003!\u0010\u0000"+ + "\u106d\u106e\u0003\r\u0006\u0000\u106e\u106f\u0003\u000f\u0007\u0000\u106f"+ + "\u1070\u00035\u001a\u0000\u1070\u0256\u0001\u0000\u0000\u0000\u1071\u1072"+ + "\u0003\u0017\u000b\u0000\u1072\u1073\u0003!\u0010\u0000\u1073\u1074\u0003"+ + "\r\u0006\u0000\u1074\u1075\u0003\u0017\u000b\u0000\u1075\u1076\u0003\u000b"+ + "\u0005\u0000\u1076\u1077\u0003\u0007\u0003\u0000\u1077\u1078\u0003-\u0016"+ + "\u0000\u1078\u1079\u0003#\u0011\u0000\u1079\u107a\u0003)\u0014\u0000\u107a"+ + "\u0258\u0001\u0000\u0000\u0000\u107b\u107c\u0003\u0017\u000b\u0000\u107c"+ + "\u107d\u0003!\u0010\u0000\u107d\u107e\u0003\u0011\b\u0000\u107e\u107f"+ + "\u0003\u0017\u000b\u0000\u107f\u1080\u00035\u001a\u0000\u1080\u025a\u0001"+ + "\u0000\u0000\u0000\u1081\u1082\u0003\u0017\u000b\u0000\u1082\u1083\u0003"+ + "!\u0010\u0000\u1083\u1084\u0003\u0015\n\u0000\u1084\u1085\u0003\u000f"+ + "\u0007\u0000\u1085\u1086\u0003)\u0014\u0000\u1086\u1087\u0003\u0017\u000b"+ + "\u0000\u1087\u1088\u0003-\u0016\u0000\u1088\u1089\u0003+\u0015\u0000\u1089"+ + "\u025c\u0001\u0000\u0000\u0000\u108a\u108b\u0003\u0017\u000b\u0000\u108b"+ + "\u108c\u0003!\u0010\u0000\u108c\u108d\u0003\u0017\u000b\u0000\u108d\u108e"+ + "\u0003-\u0016\u0000\u108e\u108f\u0003\u0017\u000b\u0000\u108f\u1090\u0003"+ + "\u0007\u0003\u0000\u1090\u1091\u0003\u001d\u000e\u0000\u1091\u1092\u0003"+ + "\u0017\u000b\u0000\u1092\u1093\u00039\u001c\u0000\u1093\u1094\u0003\u000f"+ + "\u0007\u0000\u1094\u025e\u0001\u0000\u0000\u0000\u1095\u1096\u0003\u0017"+ + "\u000b\u0000\u1096\u1097\u0003!\u0010\u0000\u1097\u1098\u0003\u0017\u000b"+ + "\u0000\u1098\u1099\u0003-\u0016\u0000\u1099\u109a\u0003\u0017\u000b\u0000"+ + "\u109a\u109b\u0003\u0007\u0003\u0000\u109b\u109c\u0003\u001d\u000e\u0000"+ + "\u109c\u109d\u0003\u001d\u000e\u0000\u109d\u109e\u00037\u001b\u0000\u109e"+ + "\u0260\u0001\u0000\u0000\u0000\u109f\u10a0\u0003\u0017\u000b\u0000\u10a0"+ + "\u10a1\u0003!\u0010\u0000\u10a1\u10a2\u0003!\u0010\u0000\u10a2\u10a3\u0003"+ + "\u000f\u0007\u0000\u10a3\u10a4\u0003)\u0014\u0000\u10a4\u0262\u0001\u0000"+ + "\u0000\u0000\u10a5\u10a6\u0003\u0017\u000b\u0000\u10a6\u10a7\u0003!\u0010"+ + "\u0000\u10a7\u10a8\u0003#\u0011\u0000\u10a8\u10a9\u0003/\u0017\u0000\u10a9"+ + "\u10aa\u0003-\u0016\u0000\u10aa\u0264\u0001\u0000\u0000\u0000\u10ab\u10ac"+ + "\u0003\u0017\u000b\u0000\u10ac\u10ad\u0003!\u0010\u0000\u10ad\u10ae\u0003"+ + "%\u0012\u0000\u10ae\u10af\u0003/\u0017\u0000\u10af\u10b0\u0003-\u0016"+ + "\u0000\u10b0\u0266\u0001\u0000\u0000\u0000\u10b1\u10b2\u0003\u0017\u000b"+ + "\u0000\u10b2\u10b3\u0003!\u0010\u0000\u10b3\u10b4\u0003+\u0015\u0000\u10b4"+ + "\u10b5\u0003\u000f\u0007\u0000\u10b5\u10b6\u0003!\u0010\u0000\u10b6\u10b7"+ + "\u0003+\u0015\u0000\u10b7\u10b8\u0003\u0017\u000b\u0000\u10b8\u10b9\u0003"+ + "-\u0016\u0000\u10b9\u10ba\u0003\u0017\u000b\u0000\u10ba\u10bb\u00031\u0018"+ + "\u0000\u10bb\u10bc\u0003\u000f\u0007\u0000\u10bc\u0268\u0001\u0000\u0000"+ + "\u0000\u10bd\u10be\u0003\u0017\u000b\u0000\u10be\u10bf\u0003!\u0010\u0000"+ + "\u10bf\u10c0\u0003+\u0015\u0000\u10c0\u10c1\u0003\u000f\u0007\u0000\u10c1"+ + "\u10c2\u0003)\u0014\u0000\u10c2\u10c3\u0003-\u0016\u0000\u10c3\u026a\u0001"+ + "\u0000\u0000\u0000\u10c4\u10c5\u0003\u0017\u000b\u0000\u10c5\u10c6\u0003"+ + "!\u0010\u0000\u10c6\u10c7\u0003+\u0015\u0000\u10c7\u10c8\u0003-\u0016"+ + "\u0000\u10c8\u10c9\u0003\u0007\u0003\u0000\u10c9\u10ca\u0003!\u0010\u0000"+ + "\u10ca\u10cb\u0003\u000b\u0005\u0000\u10cb\u10cc\u0003\u000f\u0007\u0000"+ + "\u10cc\u026c\u0001\u0000\u0000\u0000\u10cd\u10ce\u0003\u0017\u000b\u0000"+ + "\u10ce\u10cf\u0003!\u0010\u0000\u10cf\u10d0\u0003+\u0015\u0000\u10d0\u10d1"+ + "\u0003-\u0016\u0000\u10d1\u10d2\u0003\u0007\u0003\u0000\u10d2\u10d3\u0003"+ + "!\u0010\u0000\u10d3\u10d4\u0003-\u0016\u0000\u10d4\u10d5\u0003\u0017\u000b"+ + "\u0000\u10d5\u10d6\u0003\u0007\u0003\u0000\u10d6\u10d7\u0003\t\u0004\u0000"+ + "\u10d7\u10d8\u0003\u001d\u000e\u0000\u10d8\u10d9\u0003\u000f\u0007\u0000"+ + "\u10d9\u026e\u0001\u0000\u0000\u0000\u10da\u10db\u0003\u0017\u000b\u0000"+ + "\u10db\u10dc\u0003!\u0010\u0000\u10dc\u10dd\u0003+\u0015\u0000\u10dd\u10de"+ + "\u0003-\u0016\u0000\u10de\u10df\u0003\u000f\u0007\u0000\u10df\u10e0\u0003"+ + "\u0007\u0003\u0000\u10e0\u10e1\u0003\r\u0006\u0000\u10e1\u0270\u0001\u0000"+ + "\u0000\u0000\u10e2\u10e3\u0003\u0017\u000b\u0000\u10e3\u10e4\u0003!\u0010"+ + "\u0000\u10e4\u10e5\u0003-\u0016\u0000\u10e5\u0272\u0001\u0000\u0000\u0000"+ + "\u10e6\u10e7\u0003\u0017\u000b\u0000\u10e7\u10e8\u0003!\u0010\u0000\u10e8"+ + "\u10e9\u0003-\u0016\u0000\u10e9\u10ea\u0003\u000f\u0007\u0000\u10ea\u10eb"+ + "\u0003\u0013\t\u0000\u10eb\u10ec\u0003\u000f\u0007\u0000\u10ec\u10ed\u0003"+ + ")\u0014\u0000\u10ed\u0274\u0001\u0000\u0000\u0000\u10ee\u10ef\u0003\u0017"+ + "\u000b\u0000\u10ef\u10f0\u0003!\u0010\u0000\u10f0\u10f1\u0003-\u0016\u0000"+ + "\u10f1\u10f2\u0003\u000f\u0007\u0000\u10f2\u10f3\u0003)\u0014\u0000\u10f3"+ + "\u10f4\u0003+\u0015\u0000\u10f4\u10f5\u0003\u000f\u0007\u0000\u10f5\u10f6"+ + "\u0003\u000b\u0005\u0000\u10f6\u10f7\u0003-\u0016\u0000\u10f7\u0276\u0001"+ + "\u0000\u0000\u0000\u10f8\u10f9\u0003\u0017\u000b\u0000\u10f9\u10fa\u0003"+ + "!\u0010\u0000\u10fa\u10fb\u0003-\u0016\u0000\u10fb\u10fc\u0003\u000f\u0007"+ + "\u0000\u10fc\u10fd\u0003)\u0014\u0000\u10fd\u10fe\u0003+\u0015\u0000\u10fe"+ + "\u10ff\u0003\u000f\u0007\u0000\u10ff\u1100\u0003\u000b\u0005\u0000\u1100"+ + "\u1101\u0003-\u0016\u0000\u1101\u1102\u0003\u0017\u000b\u0000\u1102\u1103"+ + "\u0003#\u0011\u0000\u1103\u1104\u0003!\u0010\u0000\u1104\u0278\u0001\u0000"+ + "\u0000\u0000\u1105\u1106\u0003\u0017\u000b\u0000\u1106\u1107\u0003!\u0010"+ + "\u0000\u1107\u1108\u0003-\u0016\u0000\u1108\u1109\u0003\u000f\u0007\u0000"+ + "\u1109\u110a\u0003)\u0014\u0000\u110a\u110b\u00031\u0018\u0000\u110b\u110c"+ + "\u0003\u0007\u0003\u0000\u110c\u110d\u0003\u001d\u000e\u0000\u110d\u027a"+ + "\u0001\u0000\u0000\u0000\u110e\u110f\u0003\u0017\u000b\u0000\u110f\u1110"+ + "\u0003!\u0010\u0000\u1110\u1111\u0003-\u0016\u0000\u1111\u1112\u0003#"+ + "\u0011\u0000\u1112\u027c\u0001\u0000\u0000\u0000\u1113\u1114\u0003\u0017"+ + "\u000b\u0000\u1114\u1115\u0003!\u0010\u0000\u1115\u1116\u00031\u0018\u0000"+ + "\u1116\u1117\u0003#\u0011\u0000\u1117\u1118\u0003\u001b\r\u0000\u1118"+ + "\u1119\u0003\u000f\u0007\u0000\u1119\u111a\u0003)\u0014\u0000\u111a\u027e"+ + "\u0001\u0000\u0000\u0000\u111b\u111c\u0003\u0017\u000b\u0000\u111c\u111d"+ + "\u0003+\u0015\u0000\u111d\u0280\u0001\u0000\u0000\u0000\u111e\u111f\u0003"+ + "\u0017\u000b\u0000\u111f\u1120\u0003+\u0015\u0000\u1120\u1121\u0003#\u0011"+ + "\u0000\u1121\u1122\u0003\u001d\u000e\u0000\u1122\u1123\u0003\u0007\u0003"+ + "\u0000\u1123\u1124\u0003-\u0016\u0000\u1124\u1125\u0003\u0017\u000b\u0000"+ + "\u1125\u1126\u0003#\u0011\u0000\u1126\u1127\u0003!\u0010\u0000\u1127\u0282"+ + "\u0001\u0000\u0000\u0000\u1128\u1129\u0003\u0017\u000b\u0000\u1129\u112a"+ + "\u0003-\u0016\u0000\u112a\u112b\u0003\u000f\u0007\u0000\u112b\u112c\u0003"+ + ")\u0014\u0000\u112c\u112d\u0003\u0007\u0003\u0000\u112d\u112e\u0003-\u0016"+ + "\u0000\u112e\u112f\u0003\u000f\u0007\u0000\u112f\u0284\u0001\u0000\u0000"+ + "\u0000\u1130\u1131\u0003\u0019\f\u0000\u1131\u1132\u0003#\u0011\u0000"+ + "\u1132\u1133\u0003\u0017\u000b\u0000\u1133\u1134\u0003!\u0010\u0000\u1134"+ + "\u0286\u0001\u0000\u0000\u0000\u1135\u1136\u0003\u001b\r\u0000\u1136\u0288"+ + "\u0001\u0000\u0000\u0000\u1137\u1138\u0003\u001b\r\u0000\u1138\u1139\u0003"+ + "\u000f\u0007\u0000\u1139\u113a\u00037\u001b\u0000\u113a\u028a\u0001\u0000"+ + "\u0000\u0000\u113b\u113c\u0003\u001b\r\u0000\u113c\u113d\u0003\u000f\u0007"+ + "\u0000\u113d\u113e\u00037\u001b\u0000\u113e\u113f\u0005_\u0000\u0000\u113f"+ + "\u1140\u0003\u001f\u000f\u0000\u1140\u1141\u0003\u000f\u0007\u0000\u1141"+ + "\u1142\u0003\u001f\u000f\u0000\u1142\u1143\u0003\t\u0004\u0000\u1143\u1144"+ + "\u0003\u000f\u0007\u0000\u1144\u1145\u0003)\u0014\u0000\u1145\u028c\u0001"+ + "\u0000\u0000\u0000\u1146\u1147\u0003\u001b\r\u0000\u1147\u1148\u0003\u000f"+ + "\u0007\u0000\u1148\u1149\u00037\u001b\u0000\u1149\u114a\u0005_\u0000\u0000"+ + "\u114a\u114b\u0003-\u0016\u0000\u114b\u114c\u00037\u001b\u0000\u114c\u114d"+ + "\u0003%\u0012\u0000\u114d\u114e\u0003\u000f\u0007\u0000\u114e\u028e\u0001"+ + "\u0000\u0000\u0000\u114f\u1150\u0003\u001d\u000e\u0000\u1150\u1151\u0003"+ + "\u0007\u0003\u0000\u1151\u1152\u0003\t\u0004\u0000\u1152\u1153\u0003\u000f"+ + "\u0007\u0000\u1153\u1154\u0003\u001d\u000e\u0000\u1154\u0290\u0001\u0000"+ + "\u0000\u0000\u1155\u1156\u0003\u001d\u000e\u0000\u1156\u1157\u0003\u0007"+ + "\u0003\u0000\u1157\u1158\u0003!\u0010\u0000\u1158\u1159\u0003\u000b\u0005"+ + "\u0000\u1159\u115a\u0003#\u0011\u0000\u115a\u115b\u0003\u001f\u000f\u0000"+ + "\u115b\u115c\u0003%\u0012\u0000\u115c\u115d\u0003\u0017\u000b\u0000\u115d"+ + "\u115e\u0003\u001d\u000e\u0000\u115e\u115f\u0003\u000f\u0007\u0000\u115f"+ + "\u1160\u0003)\u0014\u0000\u1160\u0292\u0001\u0000\u0000\u0000\u1161\u1162"+ + "\u0003\u001d\u000e\u0000\u1162\u1163\u0003\u0007\u0003\u0000\u1163\u1164"+ + "\u0003!\u0010\u0000\u1164\u1165\u0003\u0013\t\u0000\u1165\u1166\u0003"+ + "/\u0017\u0000\u1166\u1167\u0003\u0007\u0003\u0000\u1167\u1168\u0003\u0013"+ + "\t\u0000\u1168\u1169\u0003\u000f\u0007\u0000\u1169\u0294\u0001\u0000\u0000"+ + "\u0000\u116a\u116b\u0003\u001d\u000e\u0000\u116b\u116c\u0003\u0007\u0003"+ + "\u0000\u116c\u116d\u0003)\u0014\u0000\u116d\u116e\u0003\u0013\t\u0000"+ + "\u116e\u116f\u0003\u000f\u0007\u0000\u116f\u0296\u0001\u0000\u0000\u0000"+ + "\u1170\u1171\u0003\u001d\u000e\u0000\u1171\u1172\u0003\u0007\u0003\u0000"+ + "\u1172\u1173\u0003+\u0015\u0000\u1173\u1174\u0003-\u0016\u0000\u1174\u0298"+ + "\u0001\u0000\u0000\u0000\u1175\u1176\u0003\u001d\u000e\u0000\u1176\u1177"+ + "\u0003\u0007\u0003\u0000\u1177\u1178\u0003-\u0016\u0000\u1178\u1179\u0003"+ + "\u000f\u0007\u0000\u1179\u117a\u0003)\u0014\u0000\u117a\u117b\u0003\u0007"+ + "\u0003\u0000\u117b\u117c\u0003\u001d\u000e\u0000\u117c\u029a\u0001\u0000"+ + "\u0000\u0000\u117d\u117e\u0003\u001d\u000e\u0000\u117e\u117f\u0003\u000f"+ + "\u0007\u0000\u117f\u1180\u0003\u0007\u0003\u0000\u1180\u1181\u0003\r\u0006"+ + "\u0000\u1181\u1182\u0003\u0017\u000b\u0000\u1182\u1183\u0003!\u0010\u0000"+ + "\u1183\u1184\u0003\u0013\t\u0000\u1184\u029c\u0001\u0000\u0000\u0000\u1185"+ + "\u1186\u0003\u001d\u000e\u0000\u1186\u1187\u0003\u000f\u0007\u0000\u1187"+ + "\u1188\u0003\u0007\u0003\u0000\u1188\u1189\u0003+\u0015\u0000\u1189\u118a"+ + "\u0003-\u0016\u0000\u118a\u029e\u0001\u0000\u0000\u0000\u118b\u118c\u0003"+ + "\u001d\u000e\u0000\u118c\u118d\u0003\u000f\u0007\u0000\u118d\u118e\u0003"+ + "\u0011\b\u0000\u118e\u118f\u0003-\u0016\u0000\u118f\u02a0\u0001\u0000"+ + "\u0000\u0000\u1190\u1191\u0003\u001d\u000e\u0000\u1191\u1192\u0003\u000f"+ + "\u0007\u0000\u1192\u1193\u0003!\u0010\u0000\u1193\u1194\u0003\u0013\t"+ + "\u0000\u1194\u1195\u0003-\u0016\u0000\u1195\u1196\u0003\u0015\n\u0000"+ + "\u1196\u02a2\u0001\u0000\u0000\u0000\u1197\u1198\u0003\u001d\u000e\u0000"+ + "\u1198\u1199\u0003\u000f\u0007\u0000\u1199\u119a\u0003+\u0015\u0000\u119a"+ + "\u119b\u0003+\u0015\u0000\u119b\u02a4\u0001\u0000\u0000\u0000\u119c\u119d"+ + "\u0003\u001d\u000e\u0000\u119d\u119e\u0003\u000f\u0007\u0000\u119e\u119f"+ + "\u00031\u0018\u0000\u119f\u11a0\u0003\u000f\u0007\u0000\u11a0\u11a1\u0003"+ + "\u001d\u000e\u0000\u11a1\u02a6\u0001\u0000\u0000\u0000\u11a2\u11a3\u0003"+ + "\u001d\u000e\u0000\u11a3\u11a4\u0003\u0017\u000b\u0000\u11a4\u11a5\u0003"+ + "\u001b\r\u0000\u11a5\u11a6\u0003\u000f\u0007\u0000\u11a6\u02a8\u0001\u0000"+ + "\u0000\u0000\u11a7\u11a8\u0003\u001d\u000e\u0000\u11a8\u11a9\u0003\u0017"+ + "\u000b\u0000\u11a9\u11aa\u0003\u001f\u000f\u0000\u11aa\u11ab\u0003\u0017"+ + "\u000b\u0000\u11ab\u11ac\u0003-\u0016\u0000\u11ac\u02aa\u0001\u0000\u0000"+ + "\u0000\u11ad\u11ae\u0003\u001d\u000e\u0000\u11ae\u11af\u0003\u0017\u000b"+ + "\u0000\u11af\u11b0\u0003+\u0015\u0000\u11b0\u11b1\u0003-\u0016\u0000\u11b1"+ + "\u11b2\u0003\u000f\u0007\u0000\u11b2\u11b3\u0003!\u0010\u0000\u11b3\u02ac"+ + "\u0001\u0000\u0000\u0000\u11b4\u11b5\u0003\u001d\u000e\u0000\u11b5\u11b6"+ + "\u0003!\u0010\u0000\u11b6\u02ae\u0001\u0000\u0000\u0000\u11b7\u11b8\u0003"+ + "\u001d\u000e\u0000\u11b8\u11b9\u0003#\u0011\u0000\u11b9\u11ba\u0003\u0007"+ + "\u0003\u0000\u11ba\u11bb\u0003\r\u0006\u0000\u11bb\u02b0\u0001\u0000\u0000"+ + "\u0000\u11bc\u11bd\u0003\u001d\u000e\u0000\u11bd\u11be\u0003#\u0011\u0000"+ + "\u11be\u11bf\u0003\u000b\u0005\u0000\u11bf\u11c0\u0003\u0007\u0003\u0000"+ + "\u11c0\u11c1\u0003\u001d\u000e\u0000\u11c1\u02b2\u0001\u0000\u0000\u0000"+ + "\u11c2\u11c3\u0003\u001d\u000e\u0000\u11c3\u11c4\u0003#\u0011\u0000\u11c4"+ + "\u11c5\u0003\u000b\u0005\u0000\u11c5\u11c6\u0003\u0007\u0003\u0000\u11c6"+ + "\u11c7\u0003\u001d\u000e\u0000\u11c7\u11c8\u0003-\u0016\u0000\u11c8\u11c9"+ + "\u0003\u0017\u000b\u0000\u11c9\u11ca\u0003\u001f\u000f\u0000\u11ca\u11cb"+ + "\u0003\u000f\u0007\u0000\u11cb\u02b4\u0001\u0000\u0000\u0000\u11cc\u11cd"+ + "\u0003\u001d\u000e\u0000\u11cd\u11ce\u0003#\u0011\u0000\u11ce\u11cf\u0003"+ + "\u000b\u0005\u0000\u11cf\u11d0\u0003\u0007\u0003\u0000\u11d0\u11d1\u0003"+ + "\u001d\u000e\u0000\u11d1\u11d2\u0003-\u0016\u0000\u11d2\u11d3\u0003\u0017"+ + "\u000b\u0000\u11d3\u11d4\u0003\u001f\u000f\u0000\u11d4\u11d5\u0003\u000f"+ + "\u0007\u0000\u11d5\u11d6\u0003+\u0015\u0000\u11d6\u11d7\u0003-\u0016\u0000"+ + "\u11d7\u11d8\u0003\u0007\u0003\u0000\u11d8\u11d9\u0003\u001f\u000f\u0000"+ + "\u11d9\u11da\u0003%\u0012\u0000\u11da\u02b6\u0001\u0000\u0000\u0000\u11db"+ + "\u11dc\u0003\u001d\u000e\u0000\u11dc\u11dd\u0003#\u0011\u0000\u11dd\u11de"+ + "\u0003\u000b\u0005\u0000\u11de\u11df\u0003\u0007\u0003\u0000\u11df\u11e0"+ + "\u0003-\u0016\u0000\u11e0\u11e1\u0003\u0017\u000b\u0000\u11e1\u11e2\u0003"+ + "#\u0011\u0000\u11e2\u11e3\u0003!\u0010\u0000\u11e3\u02b8\u0001\u0000\u0000"+ + "\u0000\u11e4\u11e5\u0003\u001d\u000e\u0000\u11e5\u11e6\u0003#\u0011\u0000"+ + "\u11e6\u11e7\u0003\u000b\u0005\u0000\u11e7\u11e8\u0003\u0007\u0003\u0000"+ + "\u11e8\u11e9\u0003-\u0016\u0000\u11e9\u11ea\u0003#\u0011\u0000\u11ea\u11eb"+ + "\u0003)\u0014\u0000\u11eb\u02ba\u0001\u0000\u0000\u0000\u11ec\u11ed\u0003"+ + "\u001d\u000e\u0000\u11ed\u11ee\u0003#\u0011\u0000\u11ee\u11ef\u0003\u000b"+ + "\u0005\u0000\u11ef\u11f0\u0003\u001b\r\u0000\u11f0\u02bc\u0001\u0000\u0000"+ + "\u0000\u11f1\u11f2\u0003\u001d\u000e\u0000\u11f2\u11f3\u0003#\u0011\u0000"+ + "\u11f3\u11f4\u0003\u000b\u0005\u0000\u11f4\u11f5\u0003\u001b\r\u0000\u11f5"+ + "\u11f6\u0003\u000f\u0007\u0000\u11f6\u11f7\u0003\r\u0006\u0000\u11f7\u02be"+ + "\u0001\u0000\u0000\u0000\u11f8\u11f9\u0003\u001d\u000e\u0000\u11f9\u11fa"+ + "\u0003#\u0011\u0000\u11fa\u11fb\u00033\u0019\u0000\u11fb\u11fc\u0003\u000f"+ + "\u0007\u0000\u11fc\u11fd\u0003)\u0014\u0000\u11fd\u02c0\u0001\u0000\u0000"+ + "\u0000\u11fe\u11ff\u0003\u001f\u000f\u0000\u11ff\u02c2\u0001\u0000\u0000"+ + "\u0000\u1200\u1201\u0003\u001f\u000f\u0000\u1201\u1202\u0003\u0007\u0003"+ + "\u0000\u1202\u1203\u0003\u0017\u000b\u0000\u1203\u1204\u0003!\u0010\u0000"+ + "\u1204\u02c4\u0001\u0000\u0000\u0000\u1205\u1206\u0003\u001f\u000f\u0000"+ + "\u1206\u1207\u0003\u0007\u0003\u0000\u1207\u1208\u0003%\u0012\u0000\u1208"+ + "\u02c6\u0001\u0000\u0000\u0000\u1209\u120a\u0003\u001f\u000f\u0000\u120a"+ + "\u120b\u0003\u0007\u0003\u0000\u120b\u120c\u0003%\u0012\u0000\u120c\u120d"+ + "\u0003%\u0012\u0000\u120d\u120e\u0003\u0017\u000b\u0000\u120e\u120f\u0003"+ + "!\u0010\u0000\u120f\u1210\u0003\u0013\t\u0000\u1210\u02c8\u0001\u0000"+ + "\u0000\u0000\u1211\u1212\u0003\u001f\u000f\u0000\u1212\u1213\u0003\u0007"+ + "\u0003\u0000\u1213\u1214\u0003-\u0016\u0000\u1214\u1215\u0003\u000b\u0005"+ + "\u0000\u1215\u1216\u0003\u0015\n\u0000\u1216\u02ca\u0001\u0000\u0000\u0000"+ + "\u1217\u1218\u0003\u001f\u000f\u0000\u1218\u1219\u0003\u0007\u0003\u0000"+ + "\u1219\u121a\u0003-\u0016\u0000\u121a\u121b\u0003\u000b\u0005\u0000\u121b"+ + "\u121c\u0003\u0015\n\u0000\u121c\u121d\u0005_\u0000\u0000\u121d\u121e"+ + "\u0003+\u0015\u0000\u121e\u121f\u0003\u0017\u000b\u0000\u121f\u1220\u0003"+ + "\u001f\u000f\u0000\u1220\u1221\u0003%\u0012\u0000\u1221\u1222\u0003\u001d"+ + "\u000e\u0000\u1222\u1223\u0003\u000f\u0007\u0000\u1223\u02cc\u0001\u0000"+ + "\u0000\u0000\u1224\u1225\u0003\u001f\u000f\u0000\u1225\u1226\u0003\u0007"+ + "\u0003\u0000\u1226\u1227\u0003-\u0016\u0000\u1227\u1228\u0003\u000b\u0005"+ + "\u0000\u1228\u1229\u0003\u0015\n\u0000\u1229\u122a\u0003\u000f\u0007\u0000"+ + "\u122a\u122b\u0003\r\u0006\u0000\u122b\u02ce\u0001\u0000\u0000\u0000\u122c"+ + "\u122d\u0003\u001f\u000f\u0000\u122d\u122e\u0003\u0007\u0003\u0000\u122e"+ + "\u122f\u00035\u001a\u0000\u122f\u02d0\u0001\u0000\u0000\u0000\u1230\u1231"+ + "\u0003\u001f\u000f\u0000\u1231\u1232\u0003\u0007\u0003\u0000\u1232\u1233"+ + "\u00035\u001a\u0000\u1233\u1234\u00031\u0018\u0000\u1234\u1235\u0003\u0007"+ + "\u0003\u0000\u1235\u1236\u0003\u001d\u000e\u0000\u1236\u1237\u0003/\u0017"+ + "\u0000\u1237\u1238\u0003\u000f\u0007\u0000\u1238\u02d2\u0001\u0000\u0000"+ + "\u0000\u1239\u123a\u0003\u001f\u000f\u0000\u123a\u123b\u0003\u000f\u0007"+ + "\u0000\u123b\u123c\u0003\u001f\u000f\u0000\u123c\u123d\u0003\t\u0004\u0000"+ + "\u123d\u123e\u0003\u000f\u0007\u0000\u123e\u123f\u0003)\u0014\u0000\u123f"+ + "\u02d4\u0001\u0000\u0000\u0000\u1240\u1241\u0003\u001f\u000f\u0000\u1241"+ + "\u1242\u0003\u000f\u0007\u0000\u1242\u1243\u0003)\u0014\u0000\u1243\u1244"+ + "\u0003\u0013\t\u0000\u1244\u1245\u0003\u000f\u0007\u0000\u1245\u02d6\u0001"+ + "\u0000\u0000\u0000\u1246\u1247\u0003\u001f\u000f\u0000\u1247\u1248\u0003"+ + "\u000f\u0007\u0000\u1248\u1249\u0003+\u0015\u0000\u1249\u124a\u0003+\u0015"+ + "\u0000\u124a\u124b\u0003\u0007\u0003\u0000\u124b\u124c\u0003\u0013\t\u0000"+ + "\u124c\u124d\u0003\u000f\u0007\u0000\u124d\u124e\u0005_\u0000\u0000\u124e"+ + "\u124f\u0003\u001d\u000e\u0000\u124f\u1250\u0003\u000f\u0007\u0000\u1250"+ + "\u1251\u0003!\u0010\u0000\u1251\u1252\u0003\u0013\t\u0000\u1252\u1253"+ + "\u0003-\u0016\u0000\u1253\u1254\u0003\u0015\n\u0000\u1254\u02d8\u0001"+ + "\u0000\u0000\u0000\u1255\u1256\u0003\u001f\u000f\u0000\u1256\u1257\u0003"+ + "\u000f\u0007\u0000\u1257\u1258\u0003+\u0015\u0000\u1258\u1259\u0003+\u0015"+ + "\u0000\u1259\u125a\u0003\u0007\u0003\u0000\u125a\u125b\u0003\u0013\t\u0000"+ + "\u125b\u125c\u0003\u000f\u0007\u0000\u125c\u125d\u0005_\u0000\u0000\u125d"+ + "\u125e\u0003#\u0011\u0000\u125e\u125f\u0003\u000b\u0005\u0000\u125f\u1260"+ + "\u0003-\u0016\u0000\u1260\u1261\u0003\u000f\u0007\u0000\u1261\u1262\u0003"+ + "-\u0016\u0000\u1262\u1263\u0005_\u0000\u0000\u1263\u1264\u0003\u001d\u000e"+ + "\u0000\u1264\u1265\u0003\u000f\u0007\u0000\u1265\u1266\u0003!\u0010\u0000"+ + "\u1266\u1267\u0003\u0013\t\u0000\u1267\u1268\u0003-\u0016\u0000\u1268"+ + "\u1269\u0003\u0015\n\u0000\u1269\u02da\u0001\u0000\u0000\u0000\u126a\u126b"+ + "\u0003\u001f\u000f\u0000\u126b\u126c\u0003\u000f\u0007\u0000\u126c\u126d"+ + "\u0003+\u0015\u0000\u126d\u126e\u0003+\u0015\u0000\u126e\u126f\u0003\u0007"+ + "\u0003\u0000\u126f\u1270\u0003\u0013\t\u0000\u1270\u1271\u0003\u000f\u0007"+ + "\u0000\u1271\u1272\u0005_\u0000\u0000\u1272\u1273\u0003-\u0016\u0000\u1273"+ + "\u1274\u0003\u000f\u0007\u0000\u1274\u1275\u00035\u001a\u0000\u1275\u1276"+ + "\u0003-\u0016\u0000\u1276\u02dc\u0001\u0000\u0000\u0000\u1277\u1278\u0003"+ + "\u001f\u000f\u0000\u1278\u1279\u0003\u000f\u0007\u0000\u1279\u127a\u0003"+ + "-\u0016\u0000\u127a\u127b\u0003\u0015\n\u0000\u127b\u127c\u0003#\u0011"+ + "\u0000\u127c\u127d\u0003\r\u0006\u0000\u127d\u02de\u0001\u0000\u0000\u0000"+ + "\u127e\u127f\u0003\u001f\u000f\u0000\u127f\u1280\u0003\u0017\u000b\u0000"+ + "\u1280\u1281\u0003!\u0010\u0000\u1281\u02e0\u0001\u0000\u0000\u0000\u1282"+ + "\u1283\u0003\u001f\u000f\u0000\u1283\u1284\u0003\u0017\u000b\u0000\u1284"+ + "\u1285\u0003!\u0010\u0000\u1285\u1286\u0003/\u0017\u0000\u1286\u1287\u0003"+ + "-\u0016\u0000\u1287\u1288\u0003\u000f\u0007\u0000\u1288\u02e2\u0001\u0000"+ + "\u0000\u0000\u1289\u128a\u0003\u001f\u000f\u0000\u128a\u128b\u0003\u0017"+ + "\u000b\u0000\u128b\u128c\u0003!\u0010\u0000\u128c\u128d\u00031\u0018\u0000"+ + "\u128d\u128e\u0003\u0007\u0003\u0000\u128e\u128f\u0003\u001d\u000e\u0000"+ + "\u128f\u1290\u0003/\u0017\u0000\u1290\u1291\u0003\u000f\u0007\u0000\u1291"+ + "\u02e4\u0001\u0000\u0000\u0000\u1292\u1293\u0003\u001f\u000f\u0000\u1293"+ + "\u1294\u0003#\u0011\u0000\u1294\u1295\u0003\r\u0006\u0000\u1295\u02e6"+ + "\u0001\u0000\u0000\u0000\u1296\u1297\u0003\u001f\u000f\u0000\u1297\u1298"+ + "\u0003#\u0011\u0000\u1298\u1299\u0003\r\u0006\u0000\u1299\u129a\u0003"+ + "\u000f\u0007\u0000\u129a\u02e8\u0001\u0000\u0000\u0000\u129b\u129c\u0003"+ + "\u001f\u000f\u0000\u129c\u129d\u0003#\u0011\u0000\u129d\u129e\u0003\r"+ + "\u0006\u0000\u129e\u129f\u0003\u0017\u000b\u0000\u129f\u12a0\u0003\u0011"+ + "\b\u0000\u12a0\u12a1\u0003\u0017\u000b\u0000\u12a1\u12a2\u0003\u000f\u0007"+ + "\u0000\u12a2\u12a3\u0003+\u0015\u0000\u12a3\u02ea\u0001\u0000\u0000\u0000"+ + "\u12a4\u12a5\u0003\u001f\u000f\u0000\u12a5\u12a6\u0003#\u0011\u0000\u12a6"+ + "\u12a7\u0003\r\u0006\u0000\u12a7\u12a8\u0003\u0017\u000b\u0000\u12a8\u12a9"+ + "\u0003\u0011\b\u0000\u12a9\u12aa\u00037\u001b\u0000\u12aa\u02ec\u0001"+ + "\u0000\u0000\u0000\u12ab\u12ac\u0003\u001f\u000f\u0000\u12ac\u12ad\u0003"+ + "#\u0011\u0000\u12ad\u12ae\u0003\r\u0006\u0000\u12ae\u12af\u0003/\u0017"+ + "\u0000\u12af\u12b0\u0003\u001d\u000e\u0000\u12b0\u12b1\u0003\u000f\u0007"+ + "\u0000\u12b1\u02ee\u0001\u0000\u0000\u0000\u12b2\u12b3\u0003\u001f\u000f"+ + "\u0000\u12b3\u12b4\u0003#\u0011\u0000\u12b4\u12b5\u0003!\u0010\u0000\u12b5"+ + "\u12b6\u0003-\u0016\u0000\u12b6\u12b7\u0003\u0015\n\u0000\u12b7\u02f0"+ + "\u0001\u0000\u0000\u0000\u12b8\u12b9\u0003\u001f\u000f\u0000\u12b9\u12ba"+ + "\u0003#\u0011\u0000\u12ba\u12bb\u0003)\u0014\u0000\u12bb\u12bc\u0003\u000f"+ + "\u0007\u0000\u12bc\u02f2\u0001\u0000\u0000\u0000\u12bd\u12be\u0003\u001f"+ + "\u000f\u0000\u12be\u12bf\u0003#\u0011\u0000\u12bf\u12c0\u00031\u0018\u0000"+ + "\u12c0\u12c1\u0003\u000f\u0007\u0000\u12c1\u02f4\u0001\u0000\u0000\u0000"+ + "\u12c2\u12c3\u0003\u001f\u000f\u0000\u12c3\u12c4\u0003/\u0017\u0000\u12c4"+ + "\u12c5\u0003\u001d\u000e\u0000\u12c5\u12c6\u0003-\u0016\u0000\u12c6\u12c7"+ + "\u0003\u0017\u000b\u0000\u12c7\u12c8\u0003+\u0015\u0000\u12c8\u12c9\u0003"+ + "\u000f\u0007\u0000\u12c9\u12ca\u0003-\u0016\u0000\u12ca\u02f6\u0001\u0000"+ + "\u0000\u0000\u12cb\u12cc\u0003\u001f\u000f\u0000\u12cc\u12cd\u0003/\u0017"+ + "\u0000\u12cd\u12ce\u0003\u001f\u000f\u0000\u12ce\u12cf\u0003%\u0012\u0000"+ + "\u12cf\u12d0\u0003+\u0015\u0000\u12d0\u02f8\u0001\u0000\u0000\u0000\u12d1"+ + "\u12d2\u0003!\u0010\u0000\u12d2\u12d3\u0003\u0007\u0003\u0000\u12d3\u12d4"+ + "\u0003\u001f\u000f\u0000\u12d4\u12d5\u0003\u000f\u0007\u0000\u12d5\u02fa"+ + "\u0001\u0000\u0000\u0000\u12d6\u12d7\u0003!\u0010\u0000\u12d7\u12d8\u0003"+ + "\u0007\u0003\u0000\u12d8\u12d9\u0003\u001f\u000f\u0000\u12d9\u12da\u0003"+ + "\u000f\u0007\u0000\u12da\u12db\u0003+\u0015\u0000\u12db\u02fc\u0001\u0000"+ + "\u0000\u0000\u12dc\u12dd\u0003!\u0010\u0000\u12dd\u12de\u0003\u0007\u0003"+ + "\u0000\u12de\u12df\u0003-\u0016\u0000\u12df\u12e0\u0003\u0017\u000b\u0000"+ + "\u12e0\u12e1\u0003#\u0011\u0000\u12e1\u12e2\u0003!\u0010\u0000\u12e2\u12e3"+ + "\u0003\u0007\u0003\u0000\u12e3\u12e4\u0003\u001d\u000e\u0000\u12e4\u02fe"+ + "\u0001\u0000\u0000\u0000\u12e5\u12e6\u0003!\u0010\u0000\u12e6\u12e7\u0003"+ + "\u0007\u0003\u0000\u12e7\u12e8\u0003-\u0016\u0000\u12e8\u12e9\u0003/\u0017"+ + "\u0000\u12e9\u12ea\u0003)\u0014\u0000\u12ea\u12eb\u0003\u0007\u0003\u0000"+ + "\u12eb\u12ec\u0003\u001d\u000e\u0000\u12ec\u0300\u0001\u0000\u0000\u0000"+ + "\u12ed\u12ee\u0003!\u0010\u0000\u12ee\u12ef\u0003\u000b\u0005\u0000\u12ef"+ + "\u12f0\u0003\u0015\n\u0000\u12f0\u12f1\u0003\u0007\u0003\u0000\u12f1\u12f2"+ + "\u0003)\u0014\u0000\u12f2\u0302\u0001\u0000\u0000\u0000\u12f3\u12f4\u0003"+ + "!\u0010\u0000\u12f4\u12f5\u0003\u000b\u0005\u0000\u12f5\u12f6\u0003\u001d"+ + "\u000e\u0000\u12f6\u12f7\u0003#\u0011\u0000\u12f7\u12f8\u0003\t\u0004"+ + "\u0000\u12f8\u0304\u0001\u0000\u0000\u0000\u12f9\u12fa\u0003!\u0010\u0000"+ + "\u12fa\u12fb\u0003\u000f\u0007\u0000\u12fb\u12fc\u0003+\u0015\u0000\u12fc"+ + "\u12fd\u0003-\u0016\u0000\u12fd\u12fe\u0003\u0017\u000b\u0000\u12fe\u12ff"+ + "\u0003!\u0010\u0000\u12ff\u1300\u0003\u0013\t\u0000\u1300\u0306\u0001"+ + "\u0000\u0000\u0000\u1301\u1302\u0003!\u0010\u0000\u1302\u1303\u0003\u000f"+ + "\u0007\u0000\u1303\u1304\u00033\u0019\u0000\u1304\u0308\u0001\u0000\u0000"+ + "\u0000\u1305\u1306\u0003!\u0010\u0000\u1306\u1307\u0003\u000f\u0007\u0000"+ + "\u1307\u1308\u00035\u001a\u0000\u1308\u1309\u0003-\u0016\u0000\u1309\u030a"+ + "\u0001\u0000\u0000\u0000\u130a\u130b\u0003!\u0010\u0000\u130b\u130c\u0003"+ + "#\u0011\u0000\u130c\u030c\u0001\u0000\u0000\u0000\u130d\u130e\u0003!\u0010"+ + "\u0000\u130e\u130f\u0003#\u0011\u0000\u130f\u1310\u0003\u000b\u0005\u0000"+ + "\u1310\u1311\u0003)\u0014\u0000\u1311\u1312\u0003\u000f\u0007\u0000\u1312"+ + "\u1313\u0003\u0007\u0003\u0000\u1313\u1314\u0003-\u0016\u0000\u1314\u1315"+ + "\u0003\u000f\u0007\u0000\u1315\u1316\u0003\r\u0006\u0000\u1316\u1317\u0003"+ + "\t\u0004\u0000\u1317\u030e\u0001\u0000\u0000\u0000\u1318\u1319\u0003!"+ + "\u0010\u0000\u1319\u131a\u0003#\u0011\u0000\u131a\u131b\u0003\u000b\u0005"+ + "\u0000\u131b\u131c\u0003)\u0014\u0000\u131c\u131d\u0003\u000f\u0007\u0000"+ + "\u131d\u131e\u0003\u0007\u0003\u0000\u131e\u131f\u0003-\u0016\u0000\u131f"+ + "\u1320\u0003\u000f\u0007\u0000\u1320\u1321\u0003/\u0017\u0000\u1321\u1322"+ + "\u0003+\u0015\u0000\u1322\u1323\u0003\u000f\u0007\u0000\u1323\u1324\u0003"+ + ")\u0014\u0000\u1324\u0310\u0001\u0000\u0000\u0000\u1325\u1326\u0003!\u0010"+ + "\u0000\u1326\u1327\u0003#\u0011\u0000\u1327\u1328\u0003!\u0010\u0000\u1328"+ + "\u1329\u0003\u000f\u0007\u0000\u1329\u0312\u0001\u0000\u0000\u0000\u132a"+ + "\u132b\u0003!\u0010\u0000\u132b\u132c\u0003#\u0011\u0000\u132c\u132d\u0003"+ + ")\u0014\u0000\u132d\u132e\u0003\u001f\u000f\u0000\u132e\u132f\u0003\u0007"+ + "\u0003\u0000\u132f\u1330\u0003\u001d\u000e\u0000\u1330\u1331\u0003\u0017"+ + "\u000b\u0000\u1331\u1332\u00039\u001c\u0000\u1332\u1333\u0003\u000f\u0007"+ + "\u0000\u1333\u0314\u0001\u0000\u0000\u0000\u1334\u1335\u0003!\u0010\u0000"+ + "\u1335\u1336\u0003#\u0011\u0000\u1336\u1337\u0003)\u0014\u0000\u1337\u1338"+ + "\u0003\u001f\u000f\u0000\u1338\u1339\u0003\u0007\u0003\u0000\u1339\u133a"+ + "\u0003\u001d\u000e\u0000\u133a\u133b\u0003\u0017\u000b\u0000\u133b\u133c"+ + "\u00039\u001c\u0000\u133c\u133d\u0003\u000f\u0007\u0000\u133d\u133e\u0003"+ + "\r\u0006\u0000\u133e\u0316\u0001\u0000\u0000\u0000\u133f\u1340\u0003!"+ + "\u0010\u0000\u1340\u1341\u0003#\u0011\u0000\u1341\u1342\u0003-\u0016\u0000"+ + "\u1342\u0318\u0001\u0000\u0000\u0000\u1343\u1344\u0003!\u0010\u0000\u1344"+ + "\u1345\u0003#\u0011\u0000\u1345\u1346\u0003-\u0016\u0000\u1346\u1347\u0003"+ + "\u0015\n\u0000\u1347\u1348\u0003\u0017\u000b\u0000\u1348\u1349\u0003!"+ + "\u0010\u0000\u1349\u134a\u0003\u0013\t\u0000\u134a\u031a\u0001\u0000\u0000"+ + "\u0000\u134b\u134c\u0003!\u0010\u0000\u134c\u134d\u0003#\u0011\u0000\u134d"+ + "\u134e\u0003-\u0016\u0000\u134e\u134f\u0003\u0017\u000b\u0000\u134f\u1350"+ + "\u0003\u0011\b\u0000\u1350\u1351\u00037\u001b\u0000\u1351\u031c\u0001"+ + "\u0000\u0000\u0000\u1352\u1353\u0003!\u0010\u0000\u1353\u1354\u0003#\u0011"+ + "\u0000\u1354\u1355\u0003-\u0016\u0000\u1355\u1356\u0003!\u0010\u0000\u1356"+ + "\u1357\u0003/\u0017\u0000\u1357\u1358\u0003\u001d\u000e\u0000\u1358\u1359"+ + "\u0003\u001d\u000e\u0000\u1359\u031e\u0001\u0000\u0000\u0000\u135a\u135b"+ + "\u0003!\u0010\u0000\u135b\u135c\u0003#\u0011\u0000\u135c\u135d\u00033"+ + "\u0019\u0000\u135d\u135e\u0003\u0007\u0003\u0000\u135e\u135f\u0003\u0017"+ + "\u000b\u0000\u135f\u1360\u0003-\u0016\u0000\u1360\u0320\u0001\u0000\u0000"+ + "\u0000\u1361\u1362\u0003!\u0010\u0000\u1362\u1363\u0003/\u0017\u0000\u1363"+ + "\u1364\u0003\u001d\u000e\u0000\u1364\u1365\u0003\u001d\u000e\u0000\u1365"+ + "\u0322\u0001\u0000\u0000\u0000\u1366\u1367\u0003!\u0010\u0000\u1367\u1368"+ + "\u0003/\u0017\u0000\u1368\u1369\u0003\u001d\u000e\u0000\u1369\u136a\u0003"+ + "\u001d\u000e\u0000\u136a\u136b\u0003\u0007\u0003\u0000\u136b\u136c\u0003"+ + "\t\u0004\u0000\u136c\u136d\u0003\u001d\u000e\u0000\u136d\u136e\u0003\u000f"+ + "\u0007\u0000\u136e\u0324\u0001\u0000\u0000\u0000\u136f\u1370\u0003!\u0010"+ + "\u0000\u1370\u1371\u0003/\u0017\u0000\u1371\u1372\u0003\u001d\u000e\u0000"+ + "\u1372\u1373\u0003\u001d\u000e\u0000\u1373\u1374\u0003\u0017\u000b\u0000"+ + "\u1374\u1375\u0003\u0011\b\u0000\u1375\u0326\u0001\u0000\u0000\u0000\u1376"+ + "\u1377\u0003!\u0010\u0000\u1377\u1378\u0003/\u0017\u0000\u1378\u1379\u0003"+ + "\u001d\u000e\u0000\u1379\u137a\u0003\u001d\u000e\u0000\u137a\u137b\u0003"+ + "+\u0015\u0000\u137b\u0328\u0001\u0000\u0000\u0000\u137c\u137d\u0003!\u0010"+ + "\u0000\u137d\u137e\u0003/\u0017\u0000\u137e\u137f\u0003\u001f\u000f\u0000"+ + "\u137f\u1380\u0003\t\u0004\u0000\u1380\u1381\u0003\u000f\u0007\u0000\u1381"+ + "\u1382\u0003)\u0014\u0000\u1382\u032a\u0001\u0000\u0000\u0000\u1383\u1384"+ + "\u0003!\u0010\u0000\u1384\u1385\u0003/\u0017\u0000\u1385\u1386\u0003\u001f"+ + "\u000f\u0000\u1386\u1387\u0003\u000f\u0007\u0000\u1387\u1388\u0003)\u0014"+ + "\u0000\u1388\u1389\u0003\u0017\u000b\u0000\u1389\u138a\u0003\u000b\u0005"+ + "\u0000\u138a\u032c\u0001\u0000\u0000\u0000\u138b\u138c\u0003#\u0011\u0000"+ + "\u138c\u138d\u0003\t\u0004\u0000\u138d\u138e\u0003\u0019\f\u0000\u138e"+ + "\u138f\u0003\u000f\u0007\u0000\u138f\u1390\u0003\u000b\u0005\u0000\u1390"+ + "\u1391\u0003-\u0016\u0000\u1391\u032e\u0001\u0000\u0000\u0000\u1392\u1393"+ + "\u0003#\u0011\u0000\u1393\u1394\u0003\u000b\u0005\u0000\u1394\u1395\u0003"+ + "-\u0016\u0000\u1395\u1396\u0003\u000f\u0007\u0000\u1396\u1397\u0003-\u0016"+ + "\u0000\u1397\u1398\u0005_\u0000\u0000\u1398\u1399\u0003\u001d\u000e\u0000"+ + "\u1399\u139a\u0003\u000f\u0007\u0000\u139a\u139b\u0003!\u0010\u0000\u139b"+ + "\u139c\u0003\u0013\t\u0000\u139c\u139d\u0003-\u0016\u0000\u139d\u139e"+ + "\u0003\u0015\n\u0000\u139e\u0330\u0001\u0000\u0000\u0000\u139f\u13a0\u0003"+ + "#\u0011\u0000\u13a0\u13a1\u0003\u000b\u0005\u0000\u13a1\u13a2\u0003-\u0016"+ + "\u0000\u13a2\u13a3\u0003\u000f\u0007\u0000\u13a3\u13a4\u0003-\u0016\u0000"+ + "\u13a4\u13a5\u0003+\u0015\u0000\u13a5\u0332\u0001\u0000\u0000\u0000\u13a6"+ + "\u13a7\u0003#\u0011\u0000\u13a7\u13a8\u0003\u0011\b\u0000\u13a8\u0334"+ + "\u0001\u0000\u0000\u0000\u13a9\u13aa\u0003#\u0011\u0000\u13aa\u13ab\u0003"+ + "\u0011\b\u0000\u13ab\u13ac\u0003\u0011\b\u0000\u13ac\u0336\u0001\u0000"+ + "\u0000\u0000\u13ad\u13ae\u0003#\u0011\u0000\u13ae\u13af\u0003\u0011\b"+ + "\u0000\u13af\u13b0\u0003\u0011\b\u0000\u13b0\u13b1\u0003+\u0015\u0000"+ + "\u13b1\u13b2\u0003\u000f\u0007\u0000\u13b2\u13b3\u0003-\u0016\u0000\u13b3"+ + "\u0338\u0001\u0000\u0000\u0000\u13b4\u13b5\u0003#\u0011\u0000\u13b5\u13b6"+ + "\u0003\u0017\u000b\u0000\u13b6\u13b7\u0003\r\u0006\u0000\u13b7\u13b8\u0003"+ + "+\u0015\u0000\u13b8\u033a\u0001\u0000\u0000\u0000\u13b9\u13ba\u0003#\u0011"+ + "\u0000\u13ba\u13bb\u0003\u001d\u000e\u0000\u13bb\u13bc\u0003\r\u0006\u0000"+ + "\u13bc\u033c\u0001\u0000\u0000\u0000\u13bd\u13be\u0003#\u0011\u0000\u13be"+ + "\u13bf\u0003!\u0010\u0000\u13bf\u033e\u0001\u0000\u0000\u0000\u13c0\u13c1"+ + "\u0003#\u0011\u0000\u13c1\u13c2\u0003!\u0010\u0000\u13c2\u13c3\u0003\u001d"+ + "\u000e\u0000\u13c3\u13c4\u00037\u001b\u0000\u13c4\u0340\u0001\u0000\u0000"+ + "\u0000\u13c5\u13c6\u0003#\u0011\u0000\u13c6\u13c7\u0003%\u0012\u0000\u13c7"+ + "\u13c8\u0003\u000f\u0007\u0000\u13c8\u13c9\u0003!\u0010\u0000\u13c9\u0342"+ + "\u0001\u0000\u0000\u0000\u13ca\u13cb\u0003#\u0011\u0000\u13cb\u13cc\u0003"+ + "%\u0012\u0000\u13cc\u13cd\u0003\u000f\u0007\u0000\u13cd\u13ce\u0003)\u0014"+ + "\u0000\u13ce\u13cf\u0003\u0007\u0003\u0000\u13cf\u13d0\u0003-\u0016\u0000"+ + "\u13d0\u13d1\u0003\u0017\u000b\u0000\u13d1\u13d2\u0003#\u0011\u0000\u13d2"+ + "\u13d3\u0003!\u0010\u0000\u13d3\u0344\u0001\u0000\u0000\u0000\u13d4\u13d5"+ + "\u0003#\u0011\u0000\u13d5\u13d6\u0003%\u0012\u0000\u13d6\u13d7\u0003\u000f"+ + "\u0007\u0000\u13d7\u13d8\u0003)\u0014\u0000\u13d8\u13d9\u0003\u0007\u0003"+ + "\u0000\u13d9\u13da\u0003-\u0016\u0000\u13da\u13db\u0003#\u0011\u0000\u13db"+ + "\u13dc\u0003)\u0014\u0000\u13dc\u0346\u0001\u0000\u0000\u0000\u13dd\u13de"+ + "\u0003#\u0011\u0000\u13de\u13df\u0003%\u0012\u0000\u13df\u13e0\u0003-"+ + "\u0016\u0000\u13e0\u13e1\u0003\u0017\u000b\u0000\u13e1\u13e2\u0003#\u0011"+ + "\u0000\u13e2\u13e3\u0003!\u0010\u0000\u13e3\u0348\u0001\u0000\u0000\u0000"+ + "\u13e4\u13e5\u0003#\u0011\u0000\u13e5\u13e6\u0003%\u0012\u0000\u13e6\u13e7"+ + "\u0003-\u0016\u0000\u13e7\u13e8\u0003\u0017\u000b\u0000\u13e8\u13e9\u0003"+ + "#\u0011\u0000\u13e9\u13ea\u0003!\u0010\u0000\u13ea\u13eb\u0003+\u0015"+ + "\u0000\u13eb\u034a\u0001\u0000\u0000\u0000\u13ec\u13ed\u0003#\u0011\u0000"+ + "\u13ed\u13ee\u0003)\u0014\u0000\u13ee\u034c\u0001\u0000\u0000\u0000\u13ef"+ + "\u13f0\u0003#\u0011\u0000\u13f0\u13f1\u0003)\u0014\u0000\u13f1\u13f2\u0003"+ + "\r\u0006\u0000\u13f2\u13f3\u0003\u000f\u0007\u0000\u13f3\u13f4\u0003)"+ + "\u0014\u0000\u13f4\u034e\u0001\u0000\u0000\u0000\u13f5\u13f6\u0003#\u0011"+ + "\u0000\u13f6\u13f7\u0003)\u0014\u0000\u13f7\u13f8\u0003\r\u0006\u0000"+ + "\u13f8\u13f9\u0003\u000f\u0007\u0000\u13f9\u13fa\u0003)\u0014\u0000\u13fa"+ + "\u13fb\u0003\u0017\u000b\u0000\u13fb\u13fc\u0003!\u0010\u0000\u13fc\u13fd"+ + "\u0003\u0013\t\u0000\u13fd\u0350\u0001\u0000\u0000\u0000\u13fe\u13ff\u0003"+ + "#\u0011\u0000\u13ff\u1400\u0003)\u0014\u0000\u1400\u1401\u0003\r\u0006"+ + "\u0000\u1401\u1402\u0003\u0017\u000b\u0000\u1402\u1403\u0003!\u0010\u0000"+ + "\u1403\u1404\u0003\u0007\u0003\u0000\u1404\u1405\u0003\u001d\u000e\u0000"+ + "\u1405\u1406\u0003\u0017\u000b\u0000\u1406\u1407\u0003-\u0016\u0000\u1407"+ + "\u1408\u00037\u001b\u0000\u1408\u0352\u0001\u0000\u0000\u0000\u1409\u140a"+ + "\u0003#\u0011\u0000\u140a\u140b\u0003-\u0016\u0000\u140b\u140c\u0003\u0015"+ + "\n\u0000\u140c\u140d\u0003\u000f\u0007\u0000\u140d\u140e\u0003)\u0014"+ + "\u0000\u140e\u140f\u0003+\u0015\u0000\u140f\u0354\u0001\u0000\u0000\u0000"+ + "\u1410\u1411\u0003#\u0011\u0000\u1411\u1412\u0003/\u0017\u0000\u1412\u1413"+ + "\u0003-\u0016\u0000\u1413\u0356\u0001\u0000\u0000\u0000\u1414\u1415\u0003"+ + "#\u0011\u0000\u1415\u1416\u0003/\u0017\u0000\u1416\u1417\u0003-\u0016"+ + "\u0000\u1417\u1418\u0003\u000f\u0007\u0000\u1418\u1419\u0003)\u0014\u0000"+ + "\u1419\u0358\u0001\u0000\u0000\u0000\u141a\u141b\u0003#\u0011\u0000\u141b"+ + "\u141c\u0003/\u0017\u0000\u141c\u141d\u0003-\u0016\u0000\u141d\u141e\u0003"+ + "%\u0012\u0000\u141e\u141f\u0003/\u0017\u0000\u141f\u1420\u0003-\u0016"+ + "\u0000\u1420\u035a\u0001\u0000\u0000\u0000\u1421\u1422\u0003#\u0011\u0000"+ + "\u1422\u1423\u00031\u0018\u0000\u1423\u1424\u0003\u000f\u0007\u0000\u1424"+ + "\u1425\u0003)\u0014\u0000\u1425\u035c\u0001\u0000\u0000\u0000\u1426\u1427"+ + "\u0003#\u0011\u0000\u1427\u1428\u00031\u0018\u0000\u1428\u1429\u0003\u000f"+ + "\u0007\u0000\u1429\u142a\u0003)\u0014\u0000\u142a\u142b\u0003\u001d\u000e"+ + "\u0000\u142b\u142c\u0003\u0007\u0003\u0000\u142c\u142d\u0003%\u0012\u0000"+ + "\u142d\u142e\u0003+\u0015\u0000\u142e\u035e\u0001\u0000\u0000\u0000\u142f"+ + "\u1430\u0003#\u0011\u0000\u1430\u1431\u00031\u0018\u0000\u1431\u1432\u0003"+ + "\u000f\u0007\u0000\u1432\u1433\u0003)\u0014\u0000\u1433\u1434\u0003\u001d"+ + "\u000e\u0000\u1434\u1435\u0003\u0007\u0003\u0000\u1435\u1436\u00037\u001b"+ + "\u0000\u1436\u0360\u0001\u0000\u0000\u0000\u1437\u1438\u0003#\u0011\u0000"+ + "\u1438\u1439\u00031\u0018\u0000\u1439\u143a\u0003\u000f\u0007\u0000\u143a"+ + "\u143b\u0003)\u0014\u0000\u143b\u143c\u0003)\u0014\u0000\u143c\u143d\u0003"+ + "\u0017\u000b\u0000\u143d\u143e\u0003\r\u0006\u0000\u143e\u143f\u0003\u0017"+ + "\u000b\u0000\u143f\u1440\u0003!\u0010\u0000\u1440\u1441\u0003\u0013\t"+ + "\u0000\u1441\u0362\u0001\u0000\u0000\u0000\u1442\u1443\u0003#\u0011\u0000"+ + "\u1443\u1444\u00033\u0019\u0000\u1444\u1445\u0003!\u0010\u0000\u1445\u1446"+ + "\u0003\u000f\u0007\u0000\u1446\u1447\u0003)\u0014\u0000\u1447\u0364\u0001"+ + "\u0000\u0000\u0000\u1448\u1449\u0003%\u0012\u0000\u1449\u144a\u0003\u0007"+ + "\u0003\u0000\u144a\u144b\u0003\r\u0006\u0000\u144b\u0366\u0001\u0000\u0000"+ + "\u0000\u144c\u144d\u0003%\u0012\u0000\u144d\u144e\u0003\u0007\u0003\u0000"+ + "\u144e\u144f\u0003)\u0014\u0000\u144f\u1450\u0003\u0007\u0003\u0000\u1450"+ + "\u1451\u0003\u001f\u000f\u0000\u1451\u1452\u0003\u000f\u0007\u0000\u1452"+ + "\u1453\u0003-\u0016\u0000\u1453\u1454\u0003\u000f\u0007\u0000\u1454\u1455"+ + "\u0003)\u0014\u0000\u1455\u0368\u0001\u0000\u0000\u0000\u1456\u1457\u0003"+ + "%\u0012\u0000\u1457\u1458\u0003\u0007\u0003\u0000\u1458\u1459\u0003)\u0014"+ + "\u0000\u1459\u145a\u0003\u0007\u0003\u0000\u145a\u145b\u0003\u001f\u000f"+ + "\u0000\u145b\u145c\u0003\u000f\u0007\u0000\u145c\u145d\u0003-\u0016\u0000"+ + "\u145d\u145e\u0003\u000f\u0007\u0000\u145e\u145f\u0003)\u0014\u0000\u145f"+ + "\u1460\u0005_\u0000\u0000\u1460\u1461\u0003\u001f\u000f\u0000\u1461\u1462"+ + "\u0003#\u0011\u0000\u1462\u1463\u0003\r\u0006\u0000\u1463\u1464\u0003"+ + "\u000f\u0007\u0000\u1464\u036a\u0001\u0000\u0000\u0000\u1465\u1466\u0003"+ + "%\u0012\u0000\u1466\u1467\u0003\u0007\u0003\u0000\u1467\u1468\u0003)\u0014"+ + "\u0000\u1468\u1469\u0003\u0007\u0003\u0000\u1469\u146a\u0003\u001f\u000f"+ + "\u0000\u146a\u146b\u0003\u000f\u0007\u0000\u146b\u146c\u0003-\u0016\u0000"+ + "\u146c\u146d\u0003\u000f\u0007\u0000\u146d\u146e\u0003)\u0014\u0000\u146e"+ + "\u146f\u0005_\u0000\u0000\u146f\u1470\u0003!\u0010\u0000\u1470\u1471\u0003"+ + "\u0007\u0003\u0000\u1471\u1472\u0003\u001f\u000f\u0000\u1472\u1473\u0003"+ + "\u000f\u0007\u0000\u1473\u036c\u0001\u0000\u0000\u0000\u1474\u1475\u0003"+ + "%\u0012\u0000\u1475\u1476\u0003\u0007\u0003\u0000\u1476\u1477\u0003)\u0014"+ + "\u0000\u1477\u1478\u0003\u0007\u0003\u0000\u1478\u1479\u0003\u001f\u000f"+ + "\u0000\u1479\u147a\u0003\u000f\u0007\u0000\u147a\u147b\u0003-\u0016\u0000"+ + "\u147b\u147c\u0003\u000f\u0007\u0000\u147c\u147d\u0003)\u0014\u0000\u147d"+ + "\u147e\u0005_\u0000\u0000\u147e\u147f\u0003#\u0011\u0000\u147f\u1480\u0003"+ + ")\u0014\u0000\u1480\u1481\u0003\r\u0006\u0000\u1481\u1482\u0003\u0017"+ + "\u000b\u0000\u1482\u1483\u0003!\u0010\u0000\u1483\u1484\u0003\u0007\u0003"+ + "\u0000\u1484\u1485\u0003\u001d\u000e\u0000\u1485\u1486\u0005_\u0000\u0000"+ + "\u1486\u1487\u0003%\u0012\u0000\u1487\u1488\u0003#\u0011\u0000\u1488\u1489"+ + "\u0003+\u0015\u0000\u1489\u148a\u0003\u0017\u000b\u0000\u148a\u148b\u0003"+ + "-\u0016\u0000\u148b\u148c\u0003\u0017\u000b\u0000\u148c\u148d\u0003#\u0011"+ + "\u0000\u148d\u148e\u0003!\u0010\u0000\u148e\u036e\u0001\u0000\u0000\u0000"+ + "\u148f\u1490\u0003%\u0012\u0000\u1490\u1491\u0003\u0007\u0003\u0000\u1491"+ + "\u1492\u0003)\u0014\u0000\u1492\u1493\u0003\u0007\u0003\u0000\u1493\u1494"+ + "\u0003\u001f\u000f\u0000\u1494\u1495\u0003\u000f\u0007\u0000\u1495\u1496"+ + "\u0003-\u0016\u0000\u1496\u1497\u0003\u000f\u0007\u0000\u1497\u1498\u0003"+ + ")\u0014\u0000\u1498\u1499\u0005_\u0000\u0000\u1499\u149a\u0003+\u0015"+ + "\u0000\u149a\u149b\u0003%\u0012\u0000\u149b\u149c\u0003\u000f\u0007\u0000"+ + "\u149c\u149d\u0003\u000b\u0005\u0000\u149d\u149e\u0003\u0017\u000b\u0000"+ + "\u149e\u149f\u0003\u0011\b\u0000\u149f\u14a0\u0003\u0017\u000b\u0000\u14a0"+ + "\u14a1\u0003\u000b\u0005\u0000\u14a1\u14a2\u0005_\u0000\u0000\u14a2\u14a3"+ + "\u0003\u000b\u0005\u0000\u14a3\u14a4\u0003\u0007\u0003\u0000\u14a4\u14a5"+ + "\u0003-\u0016\u0000\u14a5\u14a6\u0003\u0007\u0003\u0000\u14a6\u14a7\u0003"+ + "\u001d\u000e\u0000\u14a7\u14a8\u0003#\u0011\u0000\u14a8\u14a9\u0003\u0013"+ + "\t\u0000\u14a9\u0370\u0001\u0000\u0000\u0000\u14aa\u14ab\u0003%\u0012"+ + "\u0000\u14ab\u14ac\u0003\u0007\u0003\u0000\u14ac\u14ad\u0003)\u0014\u0000"+ + "\u14ad\u14ae\u0003\u0007\u0003\u0000\u14ae\u14af\u0003\u001f\u000f\u0000"+ + "\u14af\u14b0\u0003\u000f\u0007\u0000\u14b0\u14b1\u0003-\u0016\u0000\u14b1"+ + "\u14b2\u0003\u000f\u0007\u0000\u14b2\u14b3\u0003)\u0014\u0000\u14b3\u14b4"+ + "\u0005_\u0000\u0000\u14b4\u14b5\u0003+\u0015\u0000\u14b5\u14b6\u0003%"+ + "\u0012\u0000\u14b6\u14b7\u0003\u000f\u0007\u0000\u14b7\u14b8\u0003\u000b"+ + "\u0005\u0000\u14b8\u14b9\u0003\u0017\u000b\u0000\u14b9\u14ba\u0003\u0011"+ + "\b\u0000\u14ba\u14bb\u0003\u0017\u000b\u0000\u14bb\u14bc\u0003\u000b\u0005"+ + "\u0000\u14bc\u14bd\u0005_\u0000\u0000\u14bd\u14be\u0003!\u0010\u0000\u14be"+ + "\u14bf\u0003\u0007\u0003\u0000\u14bf\u14c0\u0003\u001f\u000f\u0000\u14c0"+ + "\u14c1\u0003\u000f\u0007\u0000\u14c1\u0372\u0001\u0000\u0000\u0000\u14c2"+ + "\u14c3\u0003%\u0012\u0000\u14c3\u14c4\u0003\u0007\u0003\u0000\u14c4\u14c5"+ + "\u0003)\u0014\u0000\u14c5\u14c6\u0003\u0007\u0003\u0000\u14c6\u14c7\u0003"+ + "\u001f\u000f\u0000\u14c7\u14c8\u0003\u000f\u0007\u0000\u14c8\u14c9\u0003"+ + "-\u0016\u0000\u14c9\u14ca\u0003\u000f\u0007\u0000\u14ca\u14cb\u0003)\u0014"+ + "\u0000\u14cb\u14cc\u0005_\u0000\u0000\u14cc\u14cd\u0003+\u0015\u0000\u14cd"+ + "\u14ce\u0003%\u0012\u0000\u14ce\u14cf\u0003\u000f\u0007\u0000\u14cf\u14d0"+ + "\u0003\u000b\u0005\u0000\u14d0\u14d1\u0003\u0017\u000b\u0000\u14d1\u14d2"+ + "\u0003\u0011\b\u0000\u14d2\u14d3\u0003\u0017\u000b\u0000\u14d3\u14d4\u0003"+ + "\u000b\u0005\u0000\u14d4\u14d5\u0005_\u0000\u0000\u14d5\u14d6\u0003+\u0015"+ + "\u0000\u14d6\u14d7\u0003\u000b\u0005\u0000\u14d7\u14d8\u0003\u0015\n\u0000"+ + "\u14d8\u14d9\u0003\u000f\u0007\u0000\u14d9\u14da\u0003\u001f\u000f\u0000"+ + "\u14da\u14db\u0003\u0007\u0003\u0000\u14db\u0374\u0001\u0000\u0000\u0000"+ + "\u14dc\u14dd\u0003%\u0012\u0000\u14dd\u14de\u0003\u0007\u0003\u0000\u14de"+ + "\u14df\u0003)\u0014\u0000\u14df\u14e0\u0003\u0007\u0003\u0000\u14e0\u14e1"+ + "\u0003\u001f\u000f\u0000\u14e1\u14e2\u0003\u000f\u0007\u0000\u14e2\u14e3"+ + "\u0003-\u0016\u0000\u14e3\u14e4\u0003\u000f\u0007\u0000\u14e4\u14e5\u0003"+ + ")\u0014\u0000\u14e5\u14e6\u0003+\u0015\u0000\u14e6\u0376\u0001\u0000\u0000"+ + "\u0000\u14e7\u14e8\u0003%\u0012\u0000\u14e8\u14e9\u0003\u0007\u0003\u0000"+ + "\u14e9\u14ea\u0003)\u0014\u0000\u14ea\u14eb\u0003+\u0015\u0000\u14eb\u14ec"+ + "\u0003\u000f\u0007\u0000\u14ec\u14ed\u0003)\u0014\u0000\u14ed\u0378\u0001"+ + "\u0000\u0000\u0000\u14ee\u14ef\u0003%\u0012\u0000\u14ef\u14f0\u0003\u0007"+ + "\u0003\u0000\u14f0\u14f1\u0003)\u0014\u0000\u14f1\u14f2\u0003-\u0016\u0000"+ + "\u14f2\u14f3\u0003\u0017\u000b\u0000\u14f3\u14f4\u0003\u0007\u0003\u0000"+ + "\u14f4\u14f5\u0003\u001d\u000e\u0000\u14f5\u037a\u0001\u0000\u0000\u0000"+ + "\u14f6\u14f7\u0003%\u0012\u0000\u14f7\u14f8\u0003\u0007\u0003\u0000\u14f8"+ + "\u14f9\u0003)\u0014\u0000\u14f9\u14fa\u0003-\u0016\u0000\u14fa\u14fb\u0003"+ + "\u0017\u000b\u0000\u14fb\u14fc\u0003-\u0016\u0000\u14fc\u14fd\u0003\u0017"+ + "\u000b\u0000\u14fd\u14fe\u0003#\u0011\u0000\u14fe\u14ff\u0003!\u0010\u0000"+ + "\u14ff\u037c\u0001\u0000\u0000\u0000\u1500\u1501\u0003%\u0012\u0000\u1501"+ + "\u1502\u0003\u0007\u0003\u0000\u1502\u1503\u0003+\u0015\u0000\u1503\u1504"+ + "\u0003\u000b\u0005\u0000\u1504\u1505\u0003\u0007\u0003\u0000\u1505\u1506"+ + "\u0003\u001d\u000e\u0000\u1506\u037e\u0001\u0000\u0000\u0000\u1507\u1508"+ + "\u0003%\u0012\u0000\u1508\u1509\u0003\u0007\u0003\u0000\u1509\u150a\u0003"+ + "+\u0015\u0000\u150a\u150b\u0003+\u0015\u0000\u150b\u150c\u00033\u0019"+ + "\u0000\u150c\u150d\u0003#\u0011\u0000\u150d\u150e\u0003)\u0014\u0000\u150e"+ + "\u150f\u0003\r\u0006\u0000\u150f\u0380\u0001\u0000\u0000\u0000\u1510\u1511"+ + "\u0003%\u0012\u0000\u1511\u1512\u0003\u0007\u0003\u0000\u1512\u1513\u0003"+ + "-\u0016\u0000\u1513\u1514\u0003\u0015\n\u0000\u1514\u0382\u0001\u0000"+ + "\u0000\u0000\u1515\u1516\u0003%\u0012\u0000\u1516\u1517\u0003\u000f\u0007"+ + "\u0000\u1517\u1518\u0003)\u0014\u0000\u1518\u1519\u0003\u000b\u0005\u0000"+ + "\u1519\u151a\u0003\u000f\u0007\u0000\u151a\u151b\u0003!\u0010\u0000\u151b"+ + "\u151c\u0003-\u0016\u0000\u151c\u151d\u0005_\u0000\u0000\u151d\u151e\u0003"+ + ")\u0014\u0000\u151e\u151f\u0003\u0007\u0003\u0000\u151f\u1520\u0003!\u0010"+ + "\u0000\u1520\u1521\u0003\u001b\r\u0000\u1521\u0384\u0001\u0000\u0000\u0000"+ + "\u1522\u1523\u0003%\u0012\u0000\u1523\u1524\u0003\u000f\u0007\u0000\u1524"+ + "\u1525\u0003)\u0014\u0000\u1525\u1526\u0003\u000b\u0005\u0000\u1526\u1527"+ + "\u0003\u000f\u0007\u0000\u1527\u1528\u0003!\u0010\u0000\u1528\u1529\u0003"+ + "-\u0016\u0000\u1529\u152a\u0003\u0017\u000b\u0000\u152a\u152b\u0003\u001d"+ + "\u000e\u0000\u152b\u152c\u0003\u000f\u0007\u0000\u152c\u152d\u0005_\u0000"+ + "\u0000\u152d\u152e\u0003\u000b\u0005\u0000\u152e\u152f\u0003#\u0011\u0000"+ + "\u152f\u1530\u0003!\u0010\u0000\u1530\u1531\u0003-\u0016\u0000\u1531\u0386"+ + "\u0001\u0000\u0000\u0000\u1532\u1533\u0003%\u0012\u0000\u1533\u1534\u0003"+ + "\u000f\u0007\u0000\u1534\u1535\u0003)\u0014\u0000\u1535\u1536\u0003\u000b"+ + "\u0005\u0000\u1536\u1537\u0003\u000f\u0007\u0000\u1537\u1538\u0003!\u0010"+ + "\u0000\u1538\u1539\u0003-\u0016\u0000\u1539\u153a\u0003\u0017\u000b\u0000"+ + "\u153a\u153b\u0003\u001d\u000e\u0000\u153b\u153c\u0003\u000f\u0007\u0000"+ + "\u153c\u153d\u0005_\u0000\u0000\u153d\u153e\u0003\r\u0006\u0000\u153e"+ + "\u153f\u0003\u0017\u000b\u0000\u153f\u1540\u0003+\u0015\u0000\u1540\u1541"+ + "\u0003\u000b\u0005\u0000\u1541\u0388\u0001\u0000\u0000\u0000\u1542\u1543"+ + "\u0003%\u0012\u0000\u1543\u1544\u0003\u001d\u000e\u0000\u1544\u1545\u0003"+ + "\u0007\u0003\u0000\u1545\u1546\u0003\u000b\u0005\u0000\u1546\u1547\u0003"+ + "\u0017\u000b\u0000\u1547\u1548\u0003!\u0010\u0000\u1548\u1549\u0003\u0013"+ + "\t\u0000\u1549\u038a\u0001\u0000\u0000\u0000\u154a\u154b\u0003%\u0012"+ + "\u0000\u154b\u154c\u0003\u001d\u000e\u0000\u154c\u154d\u0003\u0007\u0003"+ + "\u0000\u154d\u154e\u0003\u0017\u000b\u0000\u154e\u154f\u0003!\u0010\u0000"+ + "\u154f\u038c\u0001\u0000\u0000\u0000\u1550\u1551\u0003%\u0012\u0000\u1551"+ + "\u1552\u0003\u001d\u000e\u0000\u1552\u1553\u0003\u0007\u0003\u0000\u1553"+ + "\u1554\u0003!\u0010\u0000\u1554\u1555\u0003+\u0015\u0000\u1555\u038e\u0001"+ + "\u0000\u0000\u0000\u1556\u1557\u0003%\u0012\u0000\u1557\u1558\u0003\u001d"+ + "\u000e\u0000\u1558\u1559\u0003\u0017\u000b\u0000\u1559\u0390\u0001\u0000"+ + "\u0000\u0000\u155a\u155b\u0003%\u0012\u0000\u155b\u155c\u0003#\u0011\u0000"+ + "\u155c\u155d\u0003+\u0015\u0000\u155d\u155e\u0003\u0017\u000b\u0000\u155e"+ + "\u155f\u0003-\u0016\u0000\u155f\u1560\u0003\u0017\u000b\u0000\u1560\u1561"+ + "\u0003#\u0011\u0000\u1561\u1562\u0003!\u0010\u0000\u1562\u0392\u0001\u0000"+ + "\u0000\u0000\u1563\u1564\u0003%\u0012\u0000\u1564\u1565\u0003#\u0011\u0000"+ + "\u1565\u1566\u0003+\u0015\u0000\u1566\u1567\u0003-\u0016\u0000\u1567\u1568"+ + "\u0003\u0011\b\u0000\u1568\u1569\u0003\u0017\u000b\u0000\u1569\u156a\u0003"+ + "5\u001a\u0000\u156a\u0394\u0001\u0000\u0000\u0000\u156b\u156c\u0003%\u0012"+ + "\u0000\u156c\u156d\u0003#\u0011\u0000\u156d\u156e\u00033\u0019\u0000\u156e"+ + "\u156f\u0003\u000f\u0007\u0000\u156f\u1570\u0003)\u0014\u0000\u1570\u0396"+ + "\u0001\u0000\u0000\u0000\u1571\u1572\u0003%\u0012\u0000\u1572\u1573\u0003"+ + ")\u0014\u0000\u1573\u1574\u0003\u000f\u0007\u0000\u1574\u1575\u0003\u000b"+ + "\u0005\u0000\u1575\u1576\u0003\u000f\u0007\u0000\u1576\u1577\u0003\r\u0006"+ + "\u0000\u1577\u1578\u0003\u0017\u000b\u0000\u1578\u1579\u0003!\u0010\u0000"+ + "\u1579\u157a\u0003\u0013\t\u0000\u157a\u0398\u0001\u0000\u0000\u0000\u157b"+ + "\u157c\u0003%\u0012\u0000\u157c\u157d\u0003)\u0014\u0000\u157d\u157e\u0003"+ + "\u000f\u0007\u0000\u157e\u157f\u0003\u000b\u0005\u0000\u157f\u1580\u0003"+ + "\u0017\u000b\u0000\u1580\u1581\u0003+\u0015\u0000\u1581\u1582\u0003\u0017"+ + "\u000b\u0000\u1582\u1583\u0003#\u0011\u0000\u1583\u1584\u0003!\u0010\u0000"+ + "\u1584\u039a\u0001\u0000\u0000\u0000\u1585\u1586\u0003%\u0012\u0000\u1586"+ + "\u1587\u0003)\u0014\u0000\u1587\u1588\u0003\u000f\u0007\u0000\u1588\u1589"+ + "\u0003\u0011\b\u0000\u1589\u158a\u0003\u0017\u000b\u0000\u158a\u158b\u0003"+ + "5\u001a\u0000\u158b\u039c\u0001\u0000\u0000\u0000\u158c\u158d\u0003%\u0012"+ + "\u0000\u158d\u158e\u0003)\u0014\u0000\u158e\u158f\u0003\u000f\u0007\u0000"+ + "\u158f\u1590\u0003#\u0011\u0000\u1590\u1591\u0003)\u0014\u0000\u1591\u1592"+ + "\u0003\r\u0006\u0000\u1592\u1593\u0003\u000f\u0007\u0000\u1593\u1594\u0003"+ + ")\u0014\u0000\u1594\u039e\u0001\u0000\u0000\u0000\u1595\u1596\u0003%\u0012"+ + "\u0000\u1596\u1597\u0003)\u0014\u0000\u1597\u1598\u0003\u000f\u0007\u0000"+ + "\u1598\u1599\u0003%\u0012\u0000\u1599\u159a\u0003\u0007\u0003\u0000\u159a"+ + "\u159b\u0003)\u0014\u0000\u159b\u159c\u0003\u000f\u0007\u0000\u159c\u03a0"+ + "\u0001\u0000\u0000\u0000\u159d\u159e\u0003%\u0012\u0000\u159e\u159f\u0003"+ + ")\u0014\u0000\u159f\u15a0\u0003\u000f\u0007\u0000\u15a0\u15a1\u0003%\u0012"+ + "\u0000\u15a1\u15a2\u0003\u0007\u0003\u0000\u15a2\u15a3\u0003)\u0014\u0000"+ + "\u15a3\u15a4\u0003\u000f\u0007\u0000\u15a4\u15a5\u0003\r\u0006\u0000\u15a5"+ + "\u03a2\u0001\u0000\u0000\u0000\u15a6\u15a7\u0003%\u0012\u0000\u15a7\u15a8"+ + "\u0003)\u0014\u0000\u15a8\u15a9\u0003\u000f\u0007\u0000\u15a9\u15aa\u0003"+ + "+\u0015\u0000\u15aa\u15ab\u0003\u000f\u0007\u0000\u15ab\u15ac\u0003)\u0014"+ + "\u0000\u15ac\u15ad\u00031\u0018\u0000\u15ad\u15ae\u0003\u000f\u0007\u0000"+ + "\u15ae\u03a4\u0001\u0000\u0000\u0000\u15af\u15b0\u0003%\u0012\u0000\u15b0"+ + "\u15b1\u0003)\u0014\u0000\u15b1\u15b2\u0003\u0017\u000b\u0000\u15b2\u15b3"+ + "\u0003\u001f\u000f\u0000\u15b3\u15b4\u0003\u0007\u0003\u0000\u15b4\u15b5"+ + "\u0003)\u0014\u0000\u15b5\u15b6\u00037\u001b\u0000\u15b6\u03a6\u0001\u0000"+ + "\u0000\u0000\u15b7\u15b8\u0003%\u0012\u0000\u15b8\u15b9\u0003)\u0014\u0000"+ + "\u15b9\u15ba\u0003\u0017\u000b\u0000\u15ba\u15bb\u0003#\u0011\u0000\u15bb"+ + "\u15bc\u0003)\u0014\u0000\u15bc\u03a8\u0001\u0000\u0000\u0000\u15bd\u15be"+ + "\u0003%\u0012\u0000\u15be\u15bf\u0003)\u0014\u0000\u15bf\u15c0\u0003\u0017"+ + "\u000b\u0000\u15c0\u15c1\u00031\u0018\u0000\u15c1\u15c2\u0003\u0017\u000b"+ + "\u0000\u15c2\u15c3\u0003\u001d\u000e\u0000\u15c3\u15c4\u0003\u000f\u0007"+ + "\u0000\u15c4\u15c5\u0003\u0013\t\u0000\u15c5\u15c6\u0003\u000f\u0007\u0000"+ + "\u15c6\u15c7\u0003+\u0015\u0000\u15c7\u03aa\u0001\u0000\u0000\u0000\u15c8"+ + "\u15c9\u0003%\u0012\u0000\u15c9\u15ca\u0003)\u0014\u0000\u15ca\u15cb\u0003"+ + "#\u0011\u0000\u15cb\u15cc\u0003\u000b\u0005\u0000\u15cc\u15cd\u0003\u000f"+ + "\u0007\u0000\u15cd\u15ce\u0003\r\u0006\u0000\u15ce\u15cf\u0003/\u0017"+ + "\u0000\u15cf\u15d0\u0003)\u0014\u0000\u15d0\u15d1\u0003\u0007\u0003\u0000"+ + "\u15d1\u15d2\u0003\u001d\u000e\u0000\u15d2\u03ac\u0001\u0000\u0000\u0000"+ + "\u15d3\u15d4\u0003%\u0012\u0000\u15d4\u15d5\u0003)\u0014\u0000\u15d5\u15d6"+ + "\u0003#\u0011\u0000\u15d6\u15d7\u0003\u000b\u0005\u0000\u15d7\u15d8\u0003"+ + "\u000f\u0007\u0000\u15d8\u15d9\u0003\r\u0006\u0000\u15d9\u15da\u0003/"+ + "\u0017\u0000\u15da\u15db\u0003)\u0014\u0000\u15db\u15dc\u0003\u000f\u0007"+ + "\u0000\u15dc\u03ae\u0001\u0000\u0000\u0000\u15dd\u15de\u0003%\u0012\u0000"+ + "\u15de\u15df\u0003/\u0017\u0000\u15df\u15e0\u0003\t\u0004\u0000\u15e0"+ + "\u15e1\u0003\u001d\u000e\u0000\u15e1\u15e2\u0003\u0017\u000b\u0000\u15e2"+ + "\u15e3\u0003\u000b\u0005\u0000\u15e3\u03b0\u0001\u0000\u0000\u0000\u15e4"+ + "\u15e5\u0003%\u0012\u0000\u15e5\u15e6\u0003/\u0017\u0000\u15e6\u15e7\u0003"+ + "\t\u0004\u0000\u15e7\u15e8\u0003\u001d\u000e\u0000\u15e8\u15e9\u0003\u0017"+ + "\u000b\u0000\u15e9\u15ea\u0003\u000b\u0005\u0000\u15ea\u15eb\u0003\u0007"+ + "\u0003\u0000\u15eb\u15ec\u0003-\u0016\u0000\u15ec\u15ed\u0003\u0017\u000b"+ + "\u0000\u15ed\u15ee\u0003#\u0011\u0000\u15ee\u15ef\u0003!\u0010\u0000\u15ef"+ + "\u03b2\u0001\u0000\u0000\u0000\u15f0\u15f1\u0003\'\u0013\u0000\u15f1\u15f2"+ + "\u0003/\u0017\u0000\u15f2\u15f3\u0003#\u0011\u0000\u15f3\u15f4\u0003-"+ + "\u0016\u0000\u15f4\u15f5\u0003\u000f\u0007\u0000\u15f5\u03b4\u0001\u0000"+ + "\u0000\u0000\u15f6\u15f7\u0003)\u0014\u0000\u15f7\u15f8\u0003\u0007\u0003"+ + "\u0000\u15f8\u15f9\u0003!\u0010\u0000\u15f9\u15fa\u0003\u0013\t\u0000"+ + "\u15fa\u15fb\u0003\u000f\u0007\u0000\u15fb\u03b6\u0001\u0000\u0000\u0000"+ + "\u15fc\u15fd\u0003)\u0014\u0000\u15fd\u15fe\u0003\u0007\u0003\u0000\u15fe"+ + "\u15ff\u0003!\u0010\u0000\u15ff\u1600\u0003\u001b\r\u0000\u1600\u03b8"+ + "\u0001\u0000\u0000\u0000\u1601\u1602\u0003)\u0014\u0000\u1602\u1603\u0003"+ + "\u000f\u0007\u0000\u1603\u1604\u0003\u0007\u0003\u0000\u1604\u1605\u0003"+ + "\r\u0006\u0000\u1605\u03ba\u0001\u0000\u0000\u0000\u1606\u1607\u0003)"+ + "\u0014\u0000\u1607\u1608\u0003\u000f\u0007\u0000\u1608\u1609\u0003\u0007"+ + "\u0003\u0000\u1609\u160a\u0003\r\u0006\u0000\u160a\u160b\u0003+\u0015"+ + "\u0000\u160b\u03bc\u0001\u0000\u0000\u0000\u160c\u160d\u0003)\u0014\u0000"+ + "\u160d\u160e\u0003\u000f\u0007\u0000\u160e\u160f\u0003\u0007\u0003\u0000"+ + "\u160f\u1610\u0003\u001d\u000e\u0000\u1610\u03be\u0001\u0000\u0000\u0000"+ + "\u1611\u1612\u0003)\u0014\u0000\u1612\u1613\u0003\u000f\u0007\u0000\u1613"+ + "\u1614\u0003\u0007\u0003\u0000\u1614\u1615\u0003+\u0015\u0000\u1615\u1616"+ + "\u0003+\u0015\u0000\u1616\u1617\u0003\u0017\u000b\u0000\u1617\u1618\u0003"+ + "\u0013\t\u0000\u1618\u1619\u0003!\u0010\u0000\u1619\u03c0\u0001\u0000"+ + "\u0000\u0000\u161a\u161b\u0003)\u0014\u0000\u161b\u161c\u0003\u000f\u0007"+ + "\u0000\u161c\u161d\u0003\u000b\u0005\u0000\u161d\u161e\u0003\u0015\n\u0000"+ + "\u161e\u161f\u0003\u000f\u0007\u0000\u161f\u1620\u0003\u000b\u0005\u0000"+ + "\u1620\u1621\u0003\u001b\r\u0000\u1621\u03c2\u0001\u0000\u0000\u0000\u1622"+ + "\u1623\u0003)\u0014\u0000\u1623\u1624\u0003\u000f\u0007\u0000\u1624\u1625"+ + "\u0003\u000b\u0005\u0000\u1625\u1626\u0003/\u0017\u0000\u1626\u1627\u0003"+ + ")\u0014\u0000\u1627\u1628\u0003+\u0015\u0000\u1628\u1629\u0003\u0017\u000b"+ + "\u0000\u1629\u162a\u00031\u0018\u0000\u162a\u162b\u0003\u000f\u0007\u0000"+ + "\u162b\u03c4\u0001\u0000\u0000\u0000\u162c\u162d\u0003)\u0014\u0000\u162d"+ + "\u162e\u0003\u000f\u0007\u0000\u162e\u162f\u0003\u0011\b\u0000\u162f\u03c6"+ + "\u0001\u0000\u0000\u0000\u1630\u1631\u0003)\u0014\u0000\u1631\u1632\u0003"+ + "\u000f\u0007\u0000\u1632\u1633\u0003\u0011\b\u0000\u1633\u1634\u0003\u000f"+ + "\u0007\u0000\u1634\u1635\u0003)\u0014\u0000\u1635\u1636\u0003\u000f\u0007"+ + "\u0000\u1636\u1637\u0003!\u0010\u0000\u1637\u1638\u0003\u000b\u0005\u0000"+ + "\u1638\u1639\u0003\u000f\u0007\u0000\u1639\u163a\u0003+\u0015\u0000\u163a"+ + "\u03c8\u0001\u0000\u0000\u0000\u163b\u163c\u0003)\u0014\u0000\u163c\u163d"+ + "\u0003\u000f\u0007\u0000\u163d\u163e\u0003\u0011\b\u0000\u163e\u163f\u0003"+ + "\u000f\u0007\u0000\u163f\u1640\u0003)\u0014\u0000\u1640\u1641\u0003\u000f"+ + "\u0007\u0000\u1641\u1642\u0003!\u0010\u0000\u1642\u1643\u0003\u000b\u0005"+ + "\u0000\u1643\u1644\u0003\u0017\u000b\u0000\u1644\u1645\u0003!\u0010\u0000"+ + "\u1645\u1646\u0003\u0013\t\u0000\u1646\u03ca\u0001\u0000\u0000\u0000\u1647"+ + "\u1648\u0003)\u0014\u0000\u1648\u1649\u0003\u000f\u0007\u0000\u1649\u164a"+ + "\u0003\u0011\b\u0000\u164a\u164b\u0003)\u0014\u0000\u164b\u164c\u0003"+ + "\u000f\u0007\u0000\u164c\u164d\u0003+\u0015\u0000\u164d\u164e\u0003\u0015"+ + "\n\u0000\u164e\u03cc\u0001\u0000\u0000\u0000\u164f\u1650\u0003)\u0014"+ + "\u0000\u1650\u1651\u0003\u000f\u0007\u0000\u1651\u1652\u0003\u0013\t\u0000"+ + "\u1652\u1653\u0003)\u0014\u0000\u1653\u1654\u0005_\u0000\u0000\u1654\u1655"+ + "\u0003\u0007\u0003\u0000\u1655\u1656\u00031\u0018\u0000\u1656\u1657\u0003"+ + "\u0013\t\u0000\u1657\u1658\u00035\u001a\u0000\u1658\u03ce\u0001\u0000"+ + "\u0000\u0000\u1659\u165a\u0003)\u0014\u0000\u165a\u165b\u0003\u000f\u0007"+ + "\u0000\u165b\u165c\u0003\u0013\t\u0000\u165c\u165d\u0003)\u0014\u0000"+ + "\u165d\u165e\u0005_\u0000\u0000\u165e\u165f\u0003\u0007\u0003\u0000\u165f"+ + "\u1660\u00031\u0018\u0000\u1660\u1661\u0003\u0013\t\u0000\u1661\u1662"+ + "\u00037\u001b\u0000\u1662\u03d0\u0001\u0000\u0000\u0000\u1663\u1664\u0003"+ + ")\u0014\u0000\u1664\u1665\u0003\u000f\u0007\u0000\u1665\u1666\u0003\u0013"+ + "\t\u0000\u1666\u1667\u0003)\u0014\u0000\u1667\u1668\u0005_\u0000\u0000"+ + "\u1668\u1669\u0003\u000b\u0005\u0000\u1669\u166a\u0003#\u0011\u0000\u166a"+ + "\u166b\u0003/\u0017\u0000\u166b\u166c\u0003!\u0010\u0000\u166c\u166d\u0003"+ + "-\u0016\u0000\u166d\u03d2\u0001\u0000\u0000\u0000\u166e\u166f\u0003)\u0014"+ + "\u0000\u166f\u1670\u0003\u000f\u0007\u0000\u1670\u1671\u0003\u0013\t\u0000"+ + "\u1671\u1672\u0003)\u0014\u0000\u1672\u1673\u0005_\u0000\u0000\u1673\u1674"+ + "\u0003\u0017\u000b\u0000\u1674\u1675\u0003!\u0010\u0000\u1675\u1676\u0003"+ + "-\u0016\u0000\u1676\u1677\u0003\u000f\u0007\u0000\u1677\u1678\u0003)\u0014"+ + "\u0000\u1678\u1679\u0003\u000b\u0005\u0000\u1679\u167a\u0003\u000f\u0007"+ + "\u0000\u167a\u167b\u0003%\u0012\u0000\u167b\u167c\u0003-\u0016\u0000\u167c"+ + "\u03d4\u0001\u0000\u0000\u0000\u167d\u167e\u0003)\u0014\u0000\u167e\u167f"+ + "\u0003\u000f\u0007\u0000\u167f\u1680\u0003\u0013\t\u0000\u1680\u1681\u0003"+ + ")\u0014\u0000\u1681\u1682\u0005_\u0000\u0000\u1682\u1683\u0003)\u0014"+ + "\u0000\u1683\u1684\u00052\u0000\u0000\u1684\u03d6\u0001\u0000\u0000\u0000"+ + "\u1685\u1686\u0003)\u0014\u0000\u1686\u1687\u0003\u000f\u0007\u0000\u1687"+ + "\u1688\u0003\u0013\t\u0000\u1688\u1689\u0003)\u0014\u0000\u1689\u168a"+ + "\u0005_\u0000\u0000\u168a\u168b\u0003+\u0015\u0000\u168b\u168c\u0003\u001d"+ + "\u000e\u0000\u168c\u168d\u0003#\u0011\u0000\u168d\u168e\u0003%\u0012\u0000"+ + "\u168e\u168f\u0003\u000f\u0007\u0000\u168f\u03d8\u0001\u0000\u0000\u0000"+ + "\u1690\u1691\u0003)\u0014\u0000\u1691\u1692\u0003\u000f\u0007\u0000\u1692"+ + "\u1693\u0003\u0013\t\u0000\u1693\u1694\u0003)\u0014\u0000\u1694\u1695"+ + "\u0005_\u0000\u0000\u1695\u1696\u0003+\u0015\u0000\u1696\u1697\u00035"+ + "\u001a\u0000\u1697\u1698\u00035\u001a\u0000\u1698\u03da\u0001\u0000\u0000"+ + "\u0000\u1699\u169a\u0003)\u0014\u0000\u169a\u169b\u0003\u000f\u0007\u0000"+ + "\u169b\u169c\u0003\u0013\t\u0000\u169c\u169d\u0003)\u0014\u0000\u169d"+ + "\u169e\u0005_\u0000\u0000\u169e\u169f\u0003+\u0015\u0000\u169f\u16a0\u0003"+ + "5\u001a\u0000\u16a0\u16a1\u00037\u001b\u0000\u16a1\u03dc\u0001\u0000\u0000"+ + "\u0000\u16a2\u16a3\u0003)\u0014\u0000\u16a3\u16a4\u0003\u000f\u0007\u0000"+ + "\u16a4\u16a5\u0003\u0013\t\u0000\u16a5\u16a6\u0003)\u0014\u0000\u16a6"+ + "\u16a7\u0005_\u0000\u0000\u16a7\u16a8\u0003+\u0015\u0000\u16a8\u16a9\u0003"+ + "7\u001b\u0000\u16a9\u16aa\u00037\u001b\u0000\u16aa\u03de\u0001\u0000\u0000"+ + "\u0000\u16ab\u16ac\u0003)\u0014\u0000\u16ac\u16ad\u0003\u000f\u0007\u0000"+ + "\u16ad\u16ae\u0003\u0017\u000b\u0000\u16ae\u16af\u0003!\u0010\u0000\u16af"+ + "\u16b0\u0003\r\u0006\u0000\u16b0\u16b1\u0003\u000f\u0007\u0000\u16b1\u16b2"+ + "\u00035\u001a\u0000\u16b2\u03e0\u0001\u0000\u0000\u0000\u16b3\u16b4\u0003"+ + ")\u0014\u0000\u16b4\u16b5\u0003\u000f\u0007\u0000\u16b5\u16b6\u0003\u001d"+ + "\u000e\u0000\u16b6\u16b7\u0003\u0007\u0003\u0000\u16b7\u16b8\u0003-\u0016"+ + "\u0000\u16b8\u16b9\u0003\u0017\u000b\u0000\u16b9\u16ba\u00031\u0018\u0000"+ + "\u16ba\u16bb\u0003\u000f\u0007\u0000\u16bb\u03e2\u0001\u0000\u0000\u0000"+ + "\u16bc\u16bd\u0003)\u0014\u0000\u16bd\u16be\u0003\u000f\u0007\u0000\u16be"+ + "\u16bf\u0003\u001d\u000e\u0000\u16bf\u16c0\u0003\u000f\u0007\u0000\u16c0"+ + "\u16c1\u0003\u0007\u0003\u0000\u16c1\u16c2\u0003+\u0015\u0000\u16c2\u16c3"+ + "\u0003\u000f\u0007\u0000\u16c3\u03e4\u0001\u0000\u0000\u0000\u16c4\u16c5"+ + "\u0003)\u0014\u0000\u16c5\u16c6\u0003\u000f\u0007\u0000\u16c6\u16c7\u0003"+ + "!\u0010\u0000\u16c7\u16c8\u0003\u0007\u0003\u0000\u16c8\u16c9\u0003\u001f"+ + "\u000f\u0000\u16c9\u16ca\u0003\u000f\u0007\u0000\u16ca\u03e6\u0001\u0000"+ + "\u0000\u0000\u16cb\u16cc\u0003)\u0014\u0000\u16cc\u16cd\u0003\u000f\u0007"+ + "\u0000\u16cd\u16ce\u0003%\u0012\u0000\u16ce\u16cf\u0003\u000f\u0007\u0000"+ + "\u16cf\u16d0\u0003\u0007\u0003\u0000\u16d0\u16d1\u0003-\u0016\u0000\u16d1"+ + "\u16d2\u0003\u0007\u0003\u0000\u16d2\u16d3\u0003\t\u0004\u0000\u16d3\u16d4"+ + "\u0003\u001d\u000e\u0000\u16d4\u16d5\u0003\u000f\u0007\u0000\u16d5\u03e8"+ + "\u0001\u0000\u0000\u0000\u16d6\u16d7\u0003)\u0014\u0000\u16d7\u16d8\u0003"+ + "\u000f\u0007\u0000\u16d8\u16d9\u0003%\u0012\u0000\u16d9\u16da\u0003\u001d"+ + "\u000e\u0000\u16da\u16db\u0003\u0007\u0003\u0000\u16db\u16dc\u0003\u000b"+ + "\u0005\u0000\u16dc\u16dd\u0003\u000f\u0007\u0000\u16dd\u03ea\u0001\u0000"+ + "\u0000\u0000\u16de\u16df\u0003)\u0014\u0000\u16df\u16e0\u0003\u000f\u0007"+ + "\u0000\u16e0\u16e1\u0003%\u0012\u0000\u16e1\u16e2\u0003\u001d\u000e\u0000"+ + "\u16e2\u16e3\u0003\u0017\u000b\u0000\u16e3\u16e4\u0003\u000b\u0005\u0000"+ + "\u16e4\u16e5\u0003\u0007\u0003\u0000\u16e5\u03ec\u0001\u0000\u0000\u0000"+ + "\u16e6\u16e7\u0003)\u0014\u0000\u16e7\u16e8\u0003\u000f\u0007\u0000\u16e8"+ + "\u16e9\u0003+\u0015\u0000\u16e9\u16ea\u0003\u000f\u0007\u0000\u16ea\u16eb"+ + "\u0003-\u0016\u0000\u16eb\u03ee\u0001\u0000\u0000\u0000\u16ec\u16ed\u0003"+ + ")\u0014\u0000\u16ed\u16ee\u0003\u000f\u0007\u0000\u16ee\u16ef\u0003+\u0015"+ + "\u0000\u16ef\u16f0\u0003-\u0016\u0000\u16f0\u16f1\u0003\u0007\u0003\u0000"+ + "\u16f1\u16f2\u0003)\u0014\u0000\u16f2\u16f3\u0003-\u0016\u0000\u16f3\u03f0"+ + "\u0001\u0000\u0000\u0000\u16f4\u16f5\u0003)\u0014\u0000\u16f5\u16f6\u0003"+ + "\u000f\u0007\u0000\u16f6\u16f7\u0003+\u0015\u0000\u16f7\u16f8\u0003-\u0016"+ + "\u0000\u16f8\u16f9\u0003)\u0014\u0000\u16f9\u16fa\u0003\u0017\u000b\u0000"+ + "\u16fa\u16fb\u0003\u000b\u0005\u0000\u16fb\u16fc\u0003-\u0016\u0000\u16fc"+ + "\u03f2\u0001\u0000\u0000\u0000\u16fd\u16fe\u0003)\u0014\u0000\u16fe\u16ff"+ + "\u0003\u000f\u0007\u0000\u16ff\u1700\u0003+\u0015\u0000\u1700\u1701\u0003"+ + "/\u0017\u0000\u1701\u1702\u0003\u001d\u000e\u0000\u1702\u1703\u0003-\u0016"+ + "\u0000\u1703\u03f4\u0001\u0000\u0000\u0000\u1704\u1705\u0003)\u0014\u0000"+ + "\u1705\u1706\u0003\u000f\u0007\u0000\u1706\u1707\u0003-\u0016\u0000\u1707"+ + "\u1708\u0003/\u0017\u0000\u1708\u1709\u0003)\u0014\u0000\u1709\u170a\u0003"+ + "!\u0010\u0000\u170a\u03f6\u0001\u0000\u0000\u0000\u170b\u170c\u0003)\u0014"+ + "\u0000\u170c\u170d\u0003\u000f\u0007\u0000\u170d\u170e\u0003-\u0016\u0000"+ + "\u170e\u170f\u0003/\u0017\u0000\u170f\u1710\u0003)\u0014\u0000\u1710\u1711"+ + "\u0003!\u0010\u0000\u1711\u1712\u0003\u000f\u0007\u0000\u1712\u1713\u0003"+ + "\r\u0006\u0000\u1713\u1714\u0005_\u0000\u0000\u1714\u1715\u0003\u000b"+ + "\u0005\u0000\u1715\u1716\u0003\u0007\u0003\u0000\u1716\u1717\u0003)\u0014"+ + "\u0000\u1717\u1718\u0003\r\u0006\u0000\u1718\u1719\u0003\u0017\u000b\u0000"+ + "\u1719\u171a\u0003!\u0010\u0000\u171a\u171b\u0003\u0007\u0003\u0000\u171b"+ + "\u171c\u0003\u001d\u000e\u0000\u171c\u171d\u0003\u0017\u000b\u0000\u171d"+ + "\u171e\u0003-\u0016\u0000\u171e\u171f\u00037\u001b\u0000\u171f\u03f8\u0001"+ + "\u0000\u0000\u0000\u1720\u1721\u0003)\u0014\u0000\u1721\u1722\u0003\u000f"+ + "\u0007\u0000\u1722\u1723\u0003-\u0016\u0000\u1723\u1724\u0003/\u0017\u0000"+ + "\u1724\u1725\u0003)\u0014\u0000\u1725\u1726\u0003!\u0010\u0000\u1726\u1727"+ + "\u0003\u000f\u0007\u0000\u1727\u1728\u0003\r\u0006\u0000\u1728\u1729\u0005"+ + "_\u0000\u0000\u1729\u172a\u0003\u001d\u000e\u0000\u172a\u172b\u0003\u000f"+ + "\u0007\u0000\u172b\u172c\u0003!\u0010\u0000\u172c\u172d\u0003\u0013\t"+ + "\u0000\u172d\u172e\u0003-\u0016\u0000\u172e\u172f\u0003\u0015\n\u0000"+ + "\u172f\u03fa\u0001\u0000\u0000\u0000\u1730\u1731\u0003)\u0014\u0000\u1731"+ + "\u1732\u0003\u000f\u0007\u0000\u1732\u1733\u0003-\u0016\u0000\u1733\u1734"+ + "\u0003/\u0017\u0000\u1734\u1735\u0003)\u0014\u0000\u1735\u1736\u0003!"+ + "\u0010\u0000\u1736\u1737\u0003\u000f\u0007\u0000\u1737\u1738\u0003\r\u0006"+ + "\u0000\u1738\u1739\u0005_\u0000\u0000\u1739\u173a\u0003#\u0011\u0000\u173a"+ + "\u173b\u0003\u000b\u0005\u0000\u173b\u173c\u0003-\u0016\u0000\u173c\u173d"+ + "\u0003\u000f\u0007\u0000\u173d\u173e\u0003-\u0016\u0000\u173e\u173f\u0005"+ + "_\u0000\u0000\u173f\u1740\u0003\u001d\u000e\u0000\u1740\u1741\u0003\u000f"+ + "\u0007\u0000\u1741\u1742\u0003!\u0010\u0000\u1742\u1743\u0003\u0013\t"+ + "\u0000\u1743\u1744\u0003-\u0016\u0000\u1744\u1745\u0003\u0015\n\u0000"+ + "\u1745\u03fc\u0001\u0000\u0000\u0000\u1746\u1747\u0003)\u0014\u0000\u1747"+ + "\u1748\u0003\u000f\u0007\u0000\u1748\u1749\u0003-\u0016\u0000\u1749\u174a"+ + "\u0003/\u0017\u0000\u174a\u174b\u0003)\u0014\u0000\u174b\u174c\u0003!"+ + "\u0010\u0000\u174c\u174d\u0003\u000f\u0007\u0000\u174d\u174e\u0003\r\u0006"+ + "\u0000\u174e\u174f\u0005_\u0000\u0000\u174f\u1750\u0003+\u0015\u0000\u1750"+ + "\u1751\u0003\'\u0013\u0000\u1751\u1752\u0003\u001d\u000e\u0000\u1752\u1753"+ + "\u0003+\u0015\u0000\u1753\u1754\u0003-\u0016\u0000\u1754\u1755\u0003\u0007"+ + "\u0003\u0000\u1755\u1756\u0003-\u0016\u0000\u1756\u1757\u0003\u000f\u0007"+ + "\u0000\u1757\u03fe\u0001\u0000\u0000\u0000\u1758\u1759\u0003)\u0014\u0000"+ + "\u1759\u175a\u0003\u000f\u0007\u0000\u175a\u175b\u0003-\u0016\u0000\u175b"+ + "\u175c\u0003/\u0017\u0000\u175c\u175d\u0003)\u0014\u0000\u175d\u175e\u0003"+ + "!\u0010\u0000\u175e\u175f\u0003\u0017\u000b\u0000\u175f\u1760\u0003!\u0010"+ + "\u0000\u1760\u1761\u0003\u0013\t\u0000\u1761\u0400\u0001\u0000\u0000\u0000"+ + "\u1762\u1763\u0003)\u0014\u0000\u1763\u1764\u0003\u000f\u0007\u0000\u1764"+ + "\u1765\u0003-\u0016\u0000\u1765\u1766\u0003/\u0017\u0000\u1766\u1767\u0003"+ + ")\u0014\u0000\u1767\u1768\u0003!\u0010\u0000\u1768\u1769\u0003+\u0015"+ + "\u0000\u1769\u0402\u0001\u0000\u0000\u0000\u176a\u176b\u0003)\u0014\u0000"+ + "\u176b\u176c\u0003\u000f\u0007\u0000\u176c\u176d\u00031\u0018\u0000\u176d"+ + "\u176e\u0003#\u0011\u0000\u176e\u176f\u0003\u001b\r\u0000\u176f\u1770"+ + "\u0003\u000f\u0007\u0000\u1770\u0404\u0001\u0000\u0000\u0000\u1771\u1772"+ + "\u0003)\u0014\u0000\u1772\u1773\u0003\u0017\u000b\u0000\u1773\u1774\u0003"+ + "\u0013\t\u0000\u1774\u1775\u0003\u0015\n\u0000\u1775\u1776\u0003-\u0016"+ + "\u0000\u1776\u0406\u0001\u0000\u0000\u0000\u1777\u1778\u0003)\u0014\u0000"+ + "\u1778\u1779\u0003#\u0011\u0000\u1779\u177a\u0003\u001d\u000e\u0000\u177a"+ + "\u177b\u0003\u000f\u0007\u0000\u177b\u0408\u0001\u0000\u0000\u0000\u177c"+ + "\u177d\u0003)\u0014\u0000\u177d\u177e\u0003#\u0011\u0000\u177e\u177f\u0003"+ + "\u001d\u000e\u0000\u177f\u1780\u0003\u001d\u000e\u0000\u1780\u1781\u0003"+ + "\t\u0004\u0000\u1781\u1782\u0003\u0007\u0003\u0000\u1782\u1783\u0003\u000b"+ + "\u0005\u0000\u1783\u1784\u0003\u001b\r\u0000\u1784\u040a\u0001\u0000\u0000"+ + "\u0000\u1785\u1786\u0003)\u0014\u0000\u1786\u1787\u0003#\u0011\u0000\u1787"+ + "\u1788\u0003\u001d\u000e\u0000\u1788\u1789\u0003\u001d\u000e\u0000\u1789"+ + "\u178a\u0003/\u0017\u0000\u178a\u178b\u0003%\u0012\u0000\u178b\u040c\u0001"+ + "\u0000\u0000\u0000\u178c\u178d\u0003)\u0014\u0000\u178d\u178e\u0003#\u0011"+ + "\u0000\u178e\u178f\u0003/\u0017\u0000\u178f\u1790\u0003-\u0016\u0000\u1790"+ + "\u1791\u0003\u0017\u000b\u0000\u1791\u1792\u0003!\u0010\u0000\u1792\u1793"+ + "\u0003\u000f\u0007\u0000\u1793\u040e\u0001\u0000\u0000\u0000\u1794\u1795"+ + "\u0003)\u0014\u0000\u1795\u1796\u0003#\u0011\u0000\u1796\u1797\u0003/"+ + "\u0017\u0000\u1797\u1798\u0003-\u0016\u0000\u1798\u1799\u0003\u0017\u000b"+ + "\u0000\u1799\u179a\u0003!\u0010\u0000\u179a\u179b\u0003\u000f\u0007\u0000"+ + "\u179b\u179c\u0005_\u0000\u0000\u179c\u179d\u0003\u000b\u0005\u0000\u179d"+ + "\u179e\u0003\u0007\u0003\u0000\u179e\u179f\u0003-\u0016\u0000\u179f\u17a0"+ + "\u0003\u0007\u0003\u0000\u17a0\u17a1\u0003\u001d\u000e\u0000\u17a1\u17a2"+ + "\u0003#\u0011\u0000\u17a2\u17a3\u0003\u0013\t\u0000\u17a3\u0410\u0001"+ + "\u0000\u0000\u0000\u17a4\u17a5\u0003)\u0014\u0000\u17a5\u17a6\u0003#\u0011"+ + "\u0000\u17a6\u17a7\u0003/\u0017\u0000\u17a7\u17a8\u0003-\u0016\u0000\u17a8"+ + "\u17a9\u0003\u0017\u000b\u0000\u17a9\u17aa\u0003!\u0010\u0000\u17aa\u17ab"+ + "\u0003\u000f\u0007\u0000\u17ab\u17ac\u0005_\u0000\u0000\u17ac\u17ad\u0003"+ + "!\u0010\u0000\u17ad\u17ae\u0003\u0007\u0003\u0000\u17ae\u17af\u0003\u001f"+ + "\u000f\u0000\u17af\u17b0\u0003\u000f\u0007\u0000\u17b0\u0412\u0001\u0000"+ + "\u0000\u0000\u17b1\u17b2\u0003)\u0014\u0000\u17b2\u17b3\u0003#\u0011\u0000"+ + "\u17b3\u17b4\u0003/\u0017\u0000\u17b4\u17b5\u0003-\u0016\u0000\u17b5\u17b6"+ + "\u0003\u0017\u000b\u0000\u17b6\u17b7\u0003!\u0010\u0000\u17b7\u17b8\u0003"+ + "\u000f\u0007\u0000\u17b8\u17b9\u0005_\u0000\u0000\u17b9\u17ba\u0003+\u0015"+ + "\u0000\u17ba\u17bb\u0003\u000b\u0005\u0000\u17bb\u17bc\u0003\u0015\n\u0000"+ + "\u17bc\u17bd\u0003\u000f\u0007\u0000\u17bd\u17be\u0003\u001f\u000f\u0000"+ + "\u17be\u17bf\u0003\u0007\u0003\u0000\u17bf\u0414\u0001\u0000\u0000\u0000"+ + "\u17c0\u17c1\u0003)\u0014\u0000\u17c1\u17c2\u0003#\u0011\u0000\u17c2\u17c3"+ + "\u00033\u0019\u0000\u17c3\u0416\u0001\u0000\u0000\u0000\u17c4\u17c5\u0003"+ + ")\u0014\u0000\u17c5\u17c6\u0003#\u0011\u0000\u17c6\u17c7\u00033\u0019"+ + "\u0000\u17c7\u17c8\u0005_\u0000\u0000\u17c8\u17c9\u0003\u000b\u0005\u0000"+ + "\u17c9\u17ca\u0003#\u0011\u0000\u17ca\u17cb\u0003/\u0017\u0000\u17cb\u17cc"+ + "\u0003!\u0010\u0000\u17cc\u17cd\u0003-\u0016\u0000\u17cd\u0418\u0001\u0000"+ + "\u0000\u0000\u17ce\u17cf\u0003)\u0014\u0000\u17cf\u17d0\u0003#\u0011\u0000"+ + "\u17d0\u17d1\u00033\u0019\u0000\u17d1\u17d2\u0005_\u0000\u0000\u17d2\u17d3"+ + "\u0003!\u0010\u0000\u17d3\u17d4\u0003/\u0017\u0000\u17d4\u17d5\u0003\u001f"+ + "\u000f\u0000\u17d5\u17d6\u0003\t\u0004\u0000\u17d6\u17d7\u0003\u000f\u0007"+ + "\u0000\u17d7\u17d8\u0003)\u0014\u0000\u17d8\u041a\u0001\u0000\u0000\u0000"+ + "\u17d9\u17da\u0003)\u0014\u0000\u17da\u17db\u0003#\u0011\u0000\u17db\u17dc"+ + "\u00033\u0019\u0000\u17dc\u17dd\u0003+\u0015\u0000\u17dd\u041c\u0001\u0000"+ + "\u0000\u0000\u17de\u17df\u0003)\u0014\u0000\u17df\u17e0\u0003/\u0017\u0000"+ + "\u17e0\u17e1\u0003\u001d\u000e\u0000\u17e1\u17e2\u0003\u000f\u0007\u0000"+ + "\u17e2\u041e\u0001\u0000\u0000\u0000\u17e3\u17e4\u0003+\u0015\u0000\u17e4"+ + "\u17e5\u0003\u0007\u0003\u0000\u17e5\u17e6\u00031\u0018\u0000\u17e6\u17e7"+ + "\u0003\u000f\u0007\u0000\u17e7\u17e8\u0003%\u0012\u0000\u17e8\u17e9\u0003"+ + "#\u0011\u0000\u17e9\u17ea\u0003\u0017\u000b\u0000\u17ea\u17eb\u0003!\u0010"+ + "\u0000\u17eb\u17ec\u0003-\u0016\u0000\u17ec\u0420\u0001\u0000\u0000\u0000"+ + "\u17ed\u17ee\u0003+\u0015\u0000\u17ee\u17ef\u0003\u000b\u0005\u0000\u17ef"+ + "\u17f0\u0003\u0007\u0003\u0000\u17f0\u17f1\u0003\u001d\u000e\u0000\u17f1"+ + "\u17f2\u0003\u000f\u0007\u0000\u17f2\u0422\u0001\u0000\u0000\u0000\u17f3"+ + "\u17f4\u0003+\u0015\u0000\u17f4\u17f5\u0003\u000b\u0005\u0000\u17f5\u17f6"+ + "\u0003\u0015\n\u0000\u17f6\u17f7\u0003\u000f\u0007\u0000\u17f7\u17f8\u0003"+ + "\u001f\u000f\u0000\u17f8\u17f9\u0003\u0007\u0003\u0000\u17f9\u0424\u0001"+ + "\u0000\u0000\u0000\u17fa\u17fb\u0003+\u0015\u0000\u17fb\u17fc\u0003\u000b"+ + "\u0005\u0000\u17fc\u17fd\u0003\u0015\n\u0000\u17fd\u17fe\u0003\u000f\u0007"+ + "\u0000\u17fe\u17ff\u0003\u001f\u000f\u0000\u17ff\u1800\u0003\u0007\u0003"+ + "\u0000\u1800\u1801\u0005_\u0000\u0000\u1801\u1802\u0003!\u0010\u0000\u1802"+ + "\u1803\u0003\u0007\u0003\u0000\u1803\u1804\u0003\u001f\u000f\u0000\u1804"+ + "\u1805\u0003\u000f\u0007\u0000\u1805\u0426\u0001\u0000\u0000\u0000\u1806"+ + "\u1807\u0003+\u0015\u0000\u1807\u1808\u0003\u000b\u0005\u0000\u1808\u1809"+ + "\u0003#\u0011\u0000\u1809\u180a\u0003%\u0012\u0000\u180a\u180b\u0003\u000f"+ + "\u0007\u0000\u180b\u0428\u0001\u0000\u0000\u0000\u180c\u180d\u0003+\u0015"+ + "\u0000\u180d\u180e\u0003\u000b\u0005\u0000\u180e\u180f\u0003#\u0011\u0000"+ + "\u180f\u1810\u0003%\u0012\u0000\u1810\u1811\u0003\u000f\u0007\u0000\u1811"+ + "\u1812\u0005_\u0000\u0000\u1812\u1813\u0003\u000b\u0005\u0000\u1813\u1814"+ + "\u0003\u0007\u0003\u0000\u1814\u1815\u0003-\u0016\u0000\u1815\u1816\u0003"+ + "\u0007\u0003\u0000\u1816\u1817\u0003\u001d\u000e\u0000\u1817\u1818\u0003"+ + "#\u0011\u0000\u1818\u1819\u0003\u0013\t\u0000\u1819\u042a\u0001\u0000"+ + "\u0000\u0000\u181a\u181b\u0003+\u0015\u0000\u181b\u181c\u0003\u000b\u0005"+ + "\u0000\u181c\u181d\u0003#\u0011\u0000\u181d\u181e\u0003%\u0012\u0000\u181e"+ + "\u181f\u0003\u000f\u0007\u0000\u181f\u1820\u0005_\u0000\u0000\u1820\u1821"+ + "\u0003!\u0010\u0000\u1821\u1822\u0003\u0007\u0003\u0000\u1822\u1823\u0003"+ + "\u001f\u000f\u0000\u1823\u1824\u0003\u000f\u0007\u0000\u1824\u042c\u0001"+ + "\u0000\u0000\u0000\u1825\u1826\u0003+\u0015\u0000\u1826\u1827\u0003\u000b"+ + "\u0005\u0000\u1827\u1828\u0003#\u0011\u0000\u1828\u1829\u0003%\u0012\u0000"+ + "\u1829\u182a\u0003\u000f\u0007\u0000\u182a\u182b\u0005_\u0000\u0000\u182b"+ + "\u182c\u0003+\u0015\u0000\u182c\u182d\u0003\u000b\u0005\u0000\u182d\u182e"+ + "\u0003\u0015\n\u0000\u182e\u182f\u0003\u000f\u0007\u0000\u182f\u1830\u0003"+ + "\u001f\u000f\u0000\u1830\u1831\u0003\u0007\u0003\u0000\u1831\u042e\u0001"+ + "\u0000\u0000\u0000\u1832\u1833\u0003+\u0015\u0000\u1833\u1834\u0003\u000b"+ + "\u0005\u0000\u1834\u1835\u0003)\u0014\u0000\u1835\u1836\u0003#\u0011\u0000"+ + "\u1836\u1837\u0003\u001d\u000e\u0000\u1837\u1838\u0003\u001d\u000e\u0000"+ + "\u1838\u0430\u0001\u0000\u0000\u0000\u1839\u183a\u0003+\u0015\u0000\u183a"+ + "\u183b\u0003\u000f\u0007\u0000\u183b\u183c\u0003\u0007\u0003\u0000\u183c"+ + "\u183d\u0003)\u0014\u0000\u183d\u183e\u0003\u000b\u0005\u0000\u183e\u183f"+ + "\u0003\u0015\n\u0000\u183f\u0432\u0001\u0000\u0000\u0000\u1840\u1841\u0003"+ + "+\u0015\u0000\u1841\u1842\u0003\u000f\u0007\u0000\u1842\u1843\u0003\u000b"+ + "\u0005\u0000\u1843\u1844\u0003#\u0011\u0000\u1844\u1845\u0003!\u0010\u0000"+ + "\u1845\u1846\u0003\r\u0006\u0000\u1846\u0434\u0001\u0000\u0000\u0000\u1847"+ + "\u1848\u0003+\u0015\u0000\u1848\u1849\u0003\u000f\u0007\u0000\u1849\u184a"+ + "\u0003\u000b\u0005\u0000\u184a\u184b\u0003-\u0016\u0000\u184b\u184c\u0003"+ + "\u0017\u000b\u0000\u184c\u184d\u0003#\u0011\u0000\u184d\u184e\u0003!\u0010"+ + "\u0000\u184e\u0436\u0001\u0000\u0000\u0000\u184f\u1850\u0003+\u0015\u0000"+ + "\u1850\u1851\u0003\u000f\u0007\u0000\u1851\u1852\u0003\u000b\u0005\u0000"+ + "\u1852\u1853\u0003/\u0017\u0000\u1853\u1854\u0003)\u0014\u0000\u1854\u1855"+ + "\u0003\u0017\u000b\u0000\u1855\u1856\u0003-\u0016\u0000\u1856\u1857\u0003"+ + "7\u001b\u0000\u1857\u0438\u0001\u0000\u0000\u0000\u1858\u1859\u0003+\u0015"+ + "\u0000\u1859\u185a\u0003\u000f\u0007\u0000\u185a\u185b\u0003\u001d\u000e"+ + "\u0000\u185b\u185c\u0003\u000f\u0007\u0000\u185c\u185d\u0003\u000b\u0005"+ + "\u0000\u185d\u185e\u0003-\u0016\u0000\u185e\u043a\u0001\u0000\u0000\u0000"+ + "\u185f\u1860\u0003+\u0015\u0000\u1860\u1861\u0003\u000f\u0007\u0000\u1861"+ + "\u1862\u0003\u001d\u000e\u0000\u1862\u1863\u0003\u0011\b\u0000\u1863\u043c"+ + "\u0001\u0000\u0000\u0000\u1864\u1865\u0003+\u0015\u0000\u1865\u1866\u0003"+ + "\u000f\u0007\u0000\u1866\u1867\u0003!\u0010\u0000\u1867\u1868\u0003+\u0015"+ + "\u0000\u1868\u1869\u0003\u0017\u000b\u0000\u1869\u186a\u0003-\u0016\u0000"+ + "\u186a\u186b\u0003\u0017\u000b\u0000\u186b\u186c\u00031\u0018\u0000\u186c"+ + "\u186d\u0003\u000f\u0007\u0000\u186d\u043e\u0001\u0000\u0000\u0000\u186e"+ + "\u186f\u0003+\u0015\u0000\u186f\u1870\u0003\u000f\u0007\u0000\u1870\u1871"+ + "\u0003\'\u0013\u0000\u1871\u1872\u0003/\u0017\u0000\u1872\u1873\u0003"+ + "\u000f\u0007\u0000\u1873\u1874\u0003!\u0010\u0000\u1874\u1875\u0003\u000b"+ + "\u0005\u0000\u1875\u1876\u0003\u000f\u0007\u0000\u1876\u0440\u0001\u0000"+ + "\u0000\u0000\u1877\u1878\u0003+\u0015\u0000\u1878\u1879\u0003\u000f\u0007"+ + "\u0000\u1879\u187a\u0003\'\u0013\u0000\u187a\u187b\u0003/\u0017\u0000"+ + "\u187b\u187c\u0003\u000f\u0007\u0000\u187c\u187d\u0003!\u0010\u0000\u187d"+ + "\u187e\u0003\u000b\u0005\u0000\u187e\u187f\u0003\u000f\u0007\u0000\u187f"+ + "\u1880\u0003+\u0015\u0000\u1880\u0442\u0001\u0000\u0000\u0000\u1881\u1882"+ + "\u0003+\u0015\u0000\u1882\u1883\u0003\u000f\u0007\u0000\u1883\u1884\u0003"+ + ")\u0014\u0000\u1884\u1885\u0003\u0017\u000b\u0000\u1885\u1886\u0003\u0007"+ + "\u0003\u0000\u1886\u1887\u0003\u001d\u000e\u0000\u1887\u1888\u0003\u0017"+ + "\u000b\u0000\u1888\u1889\u00039\u001c\u0000\u1889\u188a\u0003\u0007\u0003"+ + "\u0000\u188a\u188b\u0003\t\u0004\u0000\u188b\u188c\u0003\u001d\u000e\u0000"+ + "\u188c\u188d\u0003\u000f\u0007\u0000\u188d\u0444\u0001\u0000\u0000\u0000"+ + "\u188e\u188f\u0003+\u0015\u0000\u188f\u1890\u0003\u000f\u0007\u0000\u1890"+ + "\u1891\u0003)\u0014\u0000\u1891\u1892\u00031\u0018\u0000\u1892\u1893\u0003"+ + "\u000f\u0007\u0000\u1893\u1894\u0003)\u0014\u0000\u1894\u1895\u0005_\u0000"+ + "\u0000\u1895\u1896\u0003!\u0010\u0000\u1896\u1897\u0003\u0007\u0003\u0000"+ + "\u1897\u1898\u0003\u001f\u000f\u0000\u1898\u1899\u0003\u000f\u0007\u0000"+ + "\u1899\u0446\u0001\u0000\u0000\u0000\u189a\u189b\u0003+\u0015\u0000\u189b"+ + "\u189c\u0003\u000f\u0007\u0000\u189c\u189d\u0003+\u0015\u0000\u189d\u189e"+ + "\u0003+\u0015\u0000\u189e\u189f\u0003\u0017\u000b\u0000\u189f\u18a0\u0003"+ + "#\u0011\u0000\u18a0\u18a1\u0003!\u0010\u0000\u18a1\u0448\u0001\u0000\u0000"+ + "\u0000\u18a2\u18a3\u0003+\u0015\u0000\u18a3\u18a4\u0003\u000f\u0007\u0000"+ + "\u18a4\u18a5\u0003+\u0015\u0000\u18a5\u18a6\u0003+\u0015\u0000\u18a6\u18a7"+ + "\u0003\u0017\u000b\u0000\u18a7\u18a8\u0003#\u0011\u0000\u18a8\u18a9\u0003"+ + "!\u0010\u0000\u18a9\u18aa\u0005_\u0000\u0000\u18aa\u18ab\u0003/\u0017"+ + "\u0000\u18ab\u18ac\u0003+\u0015\u0000\u18ac\u18ad\u0003\u000f\u0007\u0000"+ + "\u18ad\u18ae\u0003)\u0014\u0000\u18ae\u044a\u0001\u0000\u0000\u0000\u18af"+ + "\u18b0\u0003+\u0015\u0000\u18b0\u18b1\u0003\u000f\u0007\u0000\u18b1\u18b2"+ + "\u0003-\u0016\u0000\u18b2\u044c\u0001\u0000\u0000\u0000\u18b3\u18b4\u0003"+ + "+\u0015\u0000\u18b4\u18b5\u0003\u000f\u0007\u0000\u18b5\u18b6\u0003-\u0016"+ + "\u0000\u18b6\u18b7\u0003#\u0011\u0000\u18b7\u18b8\u0003\u0011\b\u0000"+ + "\u18b8\u044e\u0001\u0000\u0000\u0000\u18b9\u18ba\u0003+\u0015\u0000\u18ba"+ + "\u18bb\u0003\u000f\u0007\u0000\u18bb\u18bc\u0003-\u0016\u0000\u18bc\u18bd"+ + "\u0003+\u0015\u0000\u18bd\u0450\u0001\u0000\u0000\u0000\u18be\u18bf\u0003"+ + "+\u0015\u0000\u18bf\u18c0\u0003\u0015\n\u0000\u18c0\u18c1\u0003\u0007"+ + "\u0003\u0000\u18c1\u18c2\u0003)\u0014\u0000\u18c2\u18c3\u0003\u000f\u0007"+ + "\u0000\u18c3\u0452\u0001\u0000\u0000\u0000\u18c4\u18c5\u0003+\u0015\u0000"+ + "\u18c5\u18c6\u0003\u0015\n\u0000\u18c6\u18c7\u0003#\u0011\u0000\u18c7"+ + "\u18c8\u00033\u0019\u0000\u18c8\u0454\u0001\u0000\u0000\u0000\u18c9\u18ca"+ + "\u0003+\u0015\u0000\u18ca\u18cb\u0003\u0017\u000b\u0000\u18cb\u18cc\u0003"+ + "\u001f\u000f\u0000\u18cc\u18cd\u0003\u0017\u000b\u0000\u18cd\u18ce\u0003"+ + "\u001d\u000e\u0000\u18ce\u18cf\u0003\u0007\u0003\u0000\u18cf\u18d0\u0003"+ + ")\u0014\u0000\u18d0\u0456\u0001\u0000\u0000\u0000\u18d1\u18d2\u0003+\u0015"+ + "\u0000\u18d2\u18d3\u0003\u0017\u000b\u0000\u18d3\u18d4\u0003\u001f\u000f"+ + "\u0000\u18d4\u18d5\u0003%\u0012\u0000\u18d5\u18d6\u0003\u001d\u000e\u0000"+ + "\u18d6\u18d7\u0003\u000f\u0007\u0000\u18d7\u0458\u0001\u0000\u0000\u0000"+ + "\u18d8\u18d9\u0003+\u0015\u0000\u18d9\u18da\u0003\u0017\u000b\u0000\u18da"+ + "\u18db\u00039\u001c\u0000\u18db\u18dc\u0003\u000f\u0007\u0000\u18dc\u045a"+ + "\u0001\u0000\u0000\u0000\u18dd\u18de\u0003+\u0015\u0000\u18de\u18df\u0003"+ + "\u001b\r\u0000\u18df\u18e0\u0003\u0017\u000b\u0000\u18e0\u18e1\u0003%"+ + "\u0012\u0000\u18e1\u045c\u0001\u0000\u0000\u0000\u18e2\u18e3\u0003+\u0015"+ + "\u0000\u18e3\u18e4\u0003\u001f\u000f\u0000\u18e4\u18e5\u0003\u0007\u0003"+ + "\u0000\u18e5\u18e6\u0003\u001d\u000e\u0000\u18e6\u18e7\u0003\u001d\u000e"+ + "\u0000\u18e7\u18e8\u0003\u0017\u000b\u0000\u18e8\u18e9\u0003!\u0010\u0000"+ + "\u18e9\u18ea\u0003-\u0016\u0000\u18ea\u045e\u0001\u0000\u0000\u0000\u18eb"+ + "\u18ec\u0003+\u0015\u0000\u18ec\u18ed\u0003!\u0010\u0000\u18ed\u18ee\u0003"+ + "\u0007\u0003\u0000\u18ee\u18ef\u0003%\u0012\u0000\u18ef\u18f0\u0003+\u0015"+ + "\u0000\u18f0\u18f1\u0003\u0015\n\u0000\u18f1\u18f2\u0003#\u0011\u0000"+ + "\u18f2\u18f3\u0003-\u0016\u0000\u18f3\u0460\u0001\u0000\u0000\u0000\u18f4"+ + "\u18f5\u0003+\u0015\u0000\u18f5\u18f6\u0003#\u0011\u0000\u18f6\u18f7\u0003"+ + "\u001f\u000f\u0000\u18f7\u18f8\u0003\u000f\u0007\u0000\u18f8\u0462\u0001"+ + "\u0000\u0000\u0000\u18f9\u18fa\u0003+\u0015\u0000\u18fa\u18fb\u0003#\u0011"+ + "\u0000\u18fb\u18fc\u0003/\u0017\u0000\u18fc\u18fd\u0003)\u0014\u0000\u18fd"+ + "\u18fe\u0003\u000b\u0005\u0000\u18fe\u18ff\u0003\u000f\u0007\u0000\u18ff"+ + "\u0464\u0001\u0000\u0000\u0000\u1900\u1901\u0003+\u0015\u0000\u1901\u1902"+ + "\u0003%\u0012\u0000\u1902\u1903\u0003\u0007\u0003\u0000\u1903\u1904\u0003"+ + "\u000b\u0005\u0000\u1904\u1905\u0003\u000f\u0007\u0000\u1905\u0466\u0001"+ + "\u0000\u0000\u0000\u1906\u1907\u0003+\u0015\u0000\u1907\u1908\u0003%\u0012"+ + "\u0000\u1908\u1909\u0003\u000f\u0007\u0000\u1909\u190a\u0003\u000b\u0005"+ + "\u0000\u190a\u190b\u0003\u0017\u000b\u0000\u190b\u190c\u0003\u0011\b\u0000"+ + "\u190c\u190d\u0003\u0017\u000b\u0000\u190d\u190e\u0003\u000b\u0005\u0000"+ + "\u190e\u0468\u0001\u0000\u0000\u0000\u190f\u1910\u0003+\u0015\u0000\u1910"+ + "\u1911\u0003%\u0012\u0000\u1911\u1912\u0003\u000f\u0007\u0000\u1912\u1913"+ + "\u0003\u000b\u0005\u0000\u1913\u1914\u0003\u0017\u000b\u0000\u1914\u1915"+ + "\u0003\u0011\b\u0000\u1915\u1916\u0003\u0017\u000b\u0000\u1916\u1917\u0003"+ + "\u000b\u0005\u0000\u1917\u1918\u0005_\u0000\u0000\u1918\u1919\u0003!\u0010"+ + "\u0000\u1919\u191a\u0003\u0007\u0003\u0000\u191a\u191b\u0003\u001f\u000f"+ + "\u0000\u191b\u191c\u0003\u000f\u0007\u0000\u191c\u046a\u0001\u0000\u0000"+ + "\u0000\u191d\u191e\u0003+\u0015\u0000\u191e\u191f\u0003%\u0012\u0000\u191f"+ + "\u1920\u0003\u000f\u0007\u0000\u1920\u1921\u0003\u000b\u0005\u0000\u1921"+ + "\u1922\u0003\u0017\u000b\u0000\u1922\u1923\u0003\u0011\b\u0000\u1923\u1924"+ + "\u0003\u0017\u000b\u0000\u1924\u1925\u0003\u000b\u0005\u0000\u1925\u1926"+ + "\u0003-\u0016\u0000\u1926\u1927\u00037\u001b\u0000\u1927\u1928\u0003%"+ + "\u0012\u0000\u1928\u1929\u0003\u000f\u0007\u0000\u1929\u046c\u0001\u0000"+ + "\u0000\u0000\u192a\u192b\u0003+\u0015\u0000\u192b\u192c\u0003\'\u0013"+ + "\u0000\u192c\u192d\u0003\u001d\u000e\u0000\u192d\u046e\u0001\u0000\u0000"+ + "\u0000\u192e\u192f\u0003+\u0015\u0000\u192f\u1930\u0003\'\u0013\u0000"+ + "\u1930\u1931\u0003\u001d\u000e\u0000\u1931\u1932\u0003\u000b\u0005\u0000"+ + "\u1932\u1933\u0003#\u0011\u0000\u1933\u1934\u0003\r\u0006\u0000\u1934"+ + "\u1935\u0003\u000f\u0007\u0000\u1935\u0470\u0001\u0000\u0000\u0000\u1936"+ + "\u1937\u0003+\u0015\u0000\u1937\u1938\u0003\'\u0013\u0000\u1938\u1939"+ + "\u0003\u001d\u000e\u0000\u1939\u193a\u0003\u000f\u0007\u0000\u193a\u193b"+ + "\u0003)\u0014\u0000\u193b\u193c\u0003)\u0014\u0000\u193c\u193d\u0003#"+ + "\u0011\u0000\u193d\u193e\u0003)\u0014\u0000\u193e\u0472\u0001\u0000\u0000"+ + "\u0000\u193f\u1940\u0003+\u0015\u0000\u1940\u1941\u0003\'\u0013\u0000"+ + "\u1941\u1942\u0003\u001d\u000e\u0000\u1942\u1943\u0003\u000f\u0007\u0000"+ + "\u1943\u1944\u00035\u001a\u0000\u1944\u1945\u0003\u000b\u0005\u0000\u1945"+ + "\u1946\u0003\u000f\u0007\u0000\u1946\u1947\u0003%\u0012\u0000\u1947\u1948"+ + "\u0003-\u0016\u0000\u1948\u1949\u0003\u0017\u000b\u0000\u1949\u194a\u0003"+ + "#\u0011\u0000\u194a\u194b\u0003!\u0010\u0000\u194b\u0474\u0001\u0000\u0000"+ + "\u0000\u194c\u194d\u0003+\u0015\u0000\u194d\u194e\u0003\'\u0013\u0000"+ + "\u194e\u194f\u0003\u001d\u000e\u0000\u194f\u1950\u0003+\u0015\u0000\u1950"+ + "\u1951\u0003-\u0016\u0000\u1951\u1952\u0003\u0007\u0003\u0000\u1952\u1953"+ + "\u0003-\u0016\u0000\u1953\u1954\u0003\u000f\u0007\u0000\u1954\u0476\u0001"+ + "\u0000\u0000\u0000\u1955\u1956\u0003+\u0015\u0000\u1956\u1957\u0003\'"+ + "\u0013\u0000\u1957\u1958\u0003\u001d\u000e\u0000\u1958\u1959\u00033\u0019"+ + "\u0000\u1959\u195a\u0003\u0007\u0003\u0000\u195a\u195b\u0003)\u0014\u0000"+ + "\u195b\u195c\u0003!\u0010\u0000\u195c\u195d\u0003\u0017\u000b\u0000\u195d"+ + "\u195e\u0003!\u0010\u0000\u195e\u195f\u0003\u0013\t\u0000\u195f\u0478"+ + "\u0001\u0000\u0000\u0000\u1960\u1961\u0003+\u0015\u0000\u1961\u1962\u0003"+ + "\'\u0013\u0000\u1962\u1963\u0003)\u0014\u0000\u1963\u1964\u0003-\u0016"+ + "\u0000\u1964\u047a\u0001\u0000\u0000\u0000\u1965\u1966\u0003+\u0015\u0000"+ + "\u1966\u1967\u0003-\u0016\u0000\u1967\u1968\u0003\u0007\u0003\u0000\u1968"+ + "\u1969\u0003\t\u0004\u0000\u1969\u196a\u0003\u001d\u000e\u0000\u196a\u196b"+ + "\u0003\u000f\u0007\u0000\u196b\u047c\u0001\u0000\u0000\u0000\u196c\u196d"+ + "\u0003+\u0015\u0000\u196d\u196e\u0003-\u0016\u0000\u196e\u196f\u0003\u0007"+ + "\u0003\u0000\u196f\u1970\u0003)\u0014\u0000\u1970\u1971\u0003-\u0016\u0000"+ + "\u1971\u047e\u0001\u0000\u0000\u0000\u1972\u1973\u0003+\u0015\u0000\u1973"+ + "\u1974\u0003-\u0016\u0000\u1974\u1975\u0003\u0007\u0003\u0000\u1975\u1976"+ + "\u0003-\u0016\u0000\u1976\u1977\u0003\u000f\u0007\u0000\u1977\u0480\u0001"+ + "\u0000\u0000\u0000\u1978\u1979\u0003+\u0015\u0000\u1979\u197a\u0003-\u0016"+ + "\u0000\u197a\u197b\u0003\u0007\u0003\u0000\u197b\u197c\u0003-\u0016\u0000"+ + "\u197c\u197d\u0003\u000f\u0007\u0000\u197d\u197e\u0003\u001f\u000f\u0000"+ + "\u197e\u197f\u0003\u000f\u0007\u0000\u197f\u1980\u0003!\u0010\u0000\u1980"+ + "\u1981\u0003-\u0016\u0000\u1981\u0482\u0001\u0000\u0000\u0000\u1982\u1983"+ + "\u0003+\u0015\u0000\u1983\u1984\u0003-\u0016\u0000\u1984\u1985\u0003\u0007"+ + "\u0003\u0000\u1985\u1986\u0003-\u0016\u0000\u1986\u1987\u0003\u0017\u000b"+ + "\u0000\u1987\u1988\u0003\u000b\u0005\u0000\u1988\u0484\u0001\u0000\u0000"+ + "\u0000\u1989\u198a\u0003+\u0015\u0000\u198a\u198b\u0003-\u0016\u0000\u198b"+ + "\u198c\u0003\u0007\u0003\u0000\u198c\u198d\u0003-\u0016\u0000\u198d\u198e"+ + "\u0003\u0017\u000b\u0000\u198e\u198f\u0003+\u0015\u0000\u198f\u1990\u0003"+ + "-\u0016\u0000\u1990\u1991\u0003\u0017\u000b\u0000\u1991\u1992\u0003\u000b"+ + "\u0005\u0000\u1992\u1993\u0003+\u0015\u0000\u1993\u0486\u0001\u0000\u0000"+ + "\u0000\u1994\u1995\u0003+\u0015\u0000\u1995\u1996\u0003-\u0016\u0000\u1996"+ + "\u1997\u0003\r\u0006\u0000\u1997\u1998\u0003\r\u0006\u0000\u1998\u1999"+ + "\u0003\u000f\u0007\u0000\u1999\u199a\u00031\u0018\u0000\u199a\u199b\u0005"+ + "_\u0000\u0000\u199b\u199c\u0003%\u0012\u0000\u199c\u199d\u0003#\u0011"+ + "\u0000\u199d\u199e\u0003%\u0012\u0000\u199e\u0488\u0001\u0000\u0000\u0000"+ + "\u199f\u19a0\u0003+\u0015\u0000\u19a0\u19a1\u0003-\u0016\u0000\u19a1\u19a2"+ + "\u0003\r\u0006\u0000\u19a2\u19a3\u0003\r\u0006\u0000\u19a3\u19a4\u0003"+ + "\u000f\u0007\u0000\u19a4\u19a5\u00031\u0018\u0000\u19a5\u19a6\u0005_\u0000"+ + "\u0000\u19a6\u19a7\u0003+\u0015\u0000\u19a7\u19a8\u0003\u0007\u0003\u0000"+ + "\u19a8\u19a9\u0003\u001f\u000f\u0000\u19a9\u19aa\u0003%\u0012\u0000\u19aa"+ + "\u048a\u0001\u0000\u0000\u0000\u19ab\u19ac\u0003+\u0015\u0000\u19ac\u19ad"+ + "\u0003-\u0016\u0000\u19ad\u19ae\u0003\r\u0006\u0000\u19ae\u19af\u0003"+ + "\u0017\u000b\u0000\u19af\u19b0\u0003!\u0010\u0000\u19b0\u048c\u0001\u0000"+ + "\u0000\u0000\u19b1\u19b2\u0003+\u0015\u0000\u19b2\u19b3\u0003-\u0016\u0000"+ + "\u19b3\u19b4\u0003\r\u0006\u0000\u19b4\u19b5\u0003#\u0011\u0000\u19b5"+ + "\u19b6\u0003/\u0017\u0000\u19b6\u19b7\u0003-\u0016\u0000\u19b7\u048e\u0001"+ + "\u0000\u0000\u0000\u19b8\u19b9\u0003+\u0015\u0000\u19b9\u19ba\u0003-\u0016"+ + "\u0000\u19ba\u19bb\u0003#\u0011\u0000\u19bb\u19bc\u0003)\u0014\u0000\u19bc"+ + "\u19bd\u0003\u0007\u0003\u0000\u19bd\u19be\u0003\u0013\t\u0000\u19be\u19bf"+ + "\u0003\u000f\u0007\u0000\u19bf\u0490\u0001\u0000\u0000\u0000\u19c0\u19c1"+ + "\u0003+\u0015\u0000\u19c1\u19c2\u0003-\u0016\u0000\u19c2\u19c3\u0003)"+ + "\u0014\u0000\u19c3\u19c4\u0003\u0017\u000b\u0000\u19c4\u19c5\u0003\u000b"+ + "\u0005\u0000\u19c5\u19c6\u0003-\u0016\u0000\u19c6\u0492\u0001\u0000\u0000"+ + "\u0000\u19c7\u19c8\u0003+\u0015\u0000\u19c8\u19c9\u0003-\u0016\u0000\u19c9"+ + "\u19ca\u0003)\u0014\u0000\u19ca\u19cb\u0003/\u0017\u0000\u19cb\u19cc\u0003"+ + "\u000b\u0005\u0000\u19cc\u19cd\u0003-\u0016\u0000\u19cd\u19ce\u0003/\u0017"+ + "\u0000\u19ce\u19cf\u0003)\u0014\u0000\u19cf\u19d0\u0003\u000f\u0007\u0000"+ + "\u19d0\u0494\u0001\u0000\u0000\u0000\u19d1\u19d2\u0003+\u0015\u0000\u19d2"+ + "\u19d3\u0003-\u0016\u0000\u19d3\u19d4\u00037\u001b\u0000\u19d4\u19d5\u0003"+ + "\u001d\u000e\u0000\u19d5\u19d6\u0003\u000f\u0007\u0000\u19d6\u0496\u0001"+ + "\u0000\u0000\u0000\u19d7\u19d8\u0003+\u0015\u0000\u19d8\u19d9\u0003/\u0017"+ + "\u0000\u19d9\u19da\u0003\t\u0004\u0000\u19da\u19db\u0003\u000b\u0005\u0000"+ + "\u19db\u19dc\u0003\u001d\u000e\u0000\u19dc\u19dd\u0003\u0007\u0003\u0000"+ + "\u19dd\u19de\u0003+\u0015\u0000\u19de\u19df\u0003+\u0015\u0000\u19df\u19e0"+ + "\u0005_\u0000\u0000\u19e0\u19e1\u0003#\u0011\u0000\u19e1\u19e2\u0003)"+ + "\u0014\u0000\u19e2\u19e3\u0003\u0017\u000b\u0000\u19e3\u19e4\u0003\u0013"+ + "\t\u0000\u19e4\u19e5\u0003\u0017\u000b\u0000\u19e5\u19e6\u0003!\u0010"+ + "\u0000\u19e6\u0498\u0001\u0000\u0000\u0000\u19e7\u19e8\u0003+\u0015\u0000"+ + "\u19e8\u19e9\u0003/\u0017\u0000\u19e9\u19ea\u0003\t\u0004\u0000\u19ea"+ + "\u19eb\u0003\u001d\u000e\u0000\u19eb\u19ec\u0003\u0017\u000b\u0000\u19ec"+ + "\u19ed\u0003+\u0015\u0000\u19ed\u19ee\u0003-\u0016\u0000\u19ee\u049a\u0001"+ + "\u0000\u0000\u0000\u19ef\u19f0\u0003+\u0015\u0000\u19f0\u19f1\u0003/\u0017"+ + "\u0000\u19f1\u19f2\u0003\t\u0004\u0000\u19f2\u19f3\u0003\u001f\u000f\u0000"+ + "\u19f3\u19f4\u0003/\u0017\u0000\u19f4\u19f5\u0003\u001d\u000e\u0000\u19f5"+ + "\u19f6\u0003-\u0016\u0000\u19f6\u19f7\u0003\u0017\u000b\u0000\u19f7\u19f8"+ + "\u0003+\u0015\u0000\u19f8\u19f9\u0003\u000f\u0007\u0000\u19f9\u19fa\u0003"+ + "-\u0016\u0000\u19fa\u049c\u0001\u0000\u0000\u0000\u19fb\u19fc\u0003+\u0015"+ + "\u0000\u19fc\u19fd\u0003/\u0017\u0000\u19fd\u19fe\u0003\t\u0004\u0000"+ + "\u19fe\u19ff\u0003+\u0015\u0000\u19ff\u1a00\u0003\u000b\u0005\u0000\u1a00"+ + "\u1a01\u0003)\u0014\u0000\u1a01\u1a02\u0003\u0017\u000b\u0000\u1a02\u1a03"+ + "\u0003%\u0012\u0000\u1a03\u1a04\u0003-\u0016\u0000\u1a04\u1a05\u0003\u0017"+ + "\u000b\u0000\u1a05\u1a06\u0003#\u0011\u0000\u1a06\u1a07\u0003!\u0010\u0000"+ + "\u1a07\u049e\u0001\u0000\u0000\u0000\u1a08\u1a09\u0003+\u0015\u0000\u1a09"+ + "\u1a0a\u0003/\u0017\u0000\u1a0a\u1a0b\u0003\t\u0004\u0000\u1a0b\u1a0c"+ + "\u0003+\u0015\u0000\u1a0c\u1a0d\u0003-\u0016\u0000\u1a0d\u1a0e\u0003)"+ + "\u0014\u0000\u1a0e\u1a0f\u0003\u0017\u000b\u0000\u1a0f\u1a10\u0003!\u0010"+ + "\u0000\u1a10\u1a11\u0003\u0013\t\u0000\u1a11\u04a0\u0001\u0000\u0000\u0000"+ + "\u1a12\u1a13\u0003+\u0015\u0000\u1a13\u1a14\u0003/\u0017\u0000\u1a14\u1a15"+ + "\u0003\u001f\u000f\u0000\u1a15\u04a2\u0001\u0000\u0000\u0000\u1a16\u1a17"+ + "\u0003+\u0015\u0000\u1a17\u1a18\u00037\u001b\u0000\u1a18\u1a19\u0003\u001f"+ + "\u000f\u0000\u1a19\u1a1a\u0003\u001f\u000f\u0000\u1a1a\u1a1b\u0003\u000f"+ + "\u0007\u0000\u1a1b\u1a1c\u0003-\u0016\u0000\u1a1c\u1a1d\u0003)\u0014\u0000"+ + "\u1a1d\u1a1e\u0003\u0017\u000b\u0000\u1a1e\u1a1f\u0003\u000b\u0005\u0000"+ + "\u1a1f\u04a4\u0001\u0000\u0000\u0000\u1a20\u1a21\u0003+\u0015\u0000\u1a21"+ + "\u1a22\u00037\u001b\u0000\u1a22\u1a23\u0003+\u0015\u0000\u1a23\u1a24\u0003"+ + "\u0017\u000b\u0000\u1a24\u1a25\u0003\r\u0006\u0000\u1a25\u04a6\u0001\u0000"+ + "\u0000\u0000\u1a26\u1a27\u0003+\u0015\u0000\u1a27\u1a28\u00037\u001b\u0000"+ + "\u1a28\u1a29\u0003+\u0015\u0000\u1a29\u1a2a\u0003-\u0016\u0000\u1a2a\u1a2b"+ + "\u0003\u000f\u0007\u0000\u1a2b\u1a2c\u0003\u001f\u000f\u0000\u1a2c\u04a8"+ + "\u0001\u0000\u0000\u0000\u1a2d\u1a2e\u0003+\u0015\u0000\u1a2e\u1a2f\u0003"+ + "7\u001b\u0000\u1a2f\u1a30\u0003+\u0015\u0000\u1a30\u1a31\u0003-\u0016"+ + "\u0000\u1a31\u1a32\u0003\u000f\u0007\u0000\u1a32\u1a33\u0003\u001f\u000f"+ + "\u0000\u1a33\u1a34\u0005_\u0000\u0000\u1a34\u1a35\u0003/\u0017\u0000\u1a35"+ + "\u1a36\u0003+\u0015\u0000\u1a36\u1a37\u0003\u000f\u0007\u0000\u1a37\u1a38"+ + "\u0003)\u0014\u0000\u1a38\u04aa\u0001\u0000\u0000\u0000\u1a39\u1a3a\u0003"+ + "-\u0016\u0000\u1a3a\u1a3b\u0003\u0007\u0003\u0000\u1a3b\u1a3c\u0003\t"+ + "\u0004\u0000\u1a3c\u1a3d\u0003\u001d\u000e\u0000\u1a3d\u1a3e\u0003\u000f"+ + "\u0007\u0000\u1a3e\u04ac\u0001\u0000\u0000\u0000\u1a3f\u1a40\u0003-\u0016"+ + "\u0000\u1a40\u1a41\u0003\u0007\u0003\u0000\u1a41\u1a42\u0003\t\u0004\u0000"+ + "\u1a42\u1a43\u0003\u001d\u000e\u0000\u1a43\u1a44\u0003\u000f\u0007\u0000"+ + "\u1a44\u1a45\u0005_\u0000\u0000\u1a45\u1a46\u0003!\u0010\u0000\u1a46\u1a47"+ + "\u0003\u0007\u0003\u0000\u1a47\u1a48\u0003\u001f\u000f\u0000\u1a48\u1a49"+ + "\u0003\u000f\u0007\u0000\u1a49\u04ae\u0001\u0000\u0000\u0000\u1a4a\u1a4b"+ + "\u0003-\u0016\u0000\u1a4b\u1a4c\u0003\u0007\u0003\u0000\u1a4c\u1a4d\u0003"+ + "\t\u0004\u0000\u1a4d\u1a4e\u0003\u001d\u000e\u0000\u1a4e\u1a4f\u0003\u000f"+ + "\u0007\u0000\u1a4f\u1a50\u0003+\u0015\u0000\u1a50\u1a51\u0003\u0007\u0003"+ + "\u0000\u1a51\u1a52\u0003\u001f\u000f\u0000\u1a52\u1a53\u0003%\u0012\u0000"+ + "\u1a53\u1a54\u0003\u001d\u000e\u0000\u1a54\u1a55\u0003\u000f\u0007\u0000"+ + "\u1a55\u04b0\u0001\u0000\u0000\u0000\u1a56\u1a57\u0003-\u0016\u0000\u1a57"+ + "\u1a58\u0003\u0007\u0003\u0000\u1a58\u1a59\u0003\t\u0004\u0000\u1a59\u1a5a"+ + "\u0003\u001d\u000e\u0000\u1a5a\u1a5b\u0003\u000f\u0007\u0000\u1a5b\u1a5c"+ + "\u0003+\u0015\u0000\u1a5c\u1a5d\u0003%\u0012\u0000\u1a5d\u1a5e\u0003\u0007"+ + "\u0003\u0000\u1a5e\u1a5f\u0003\u000b\u0005\u0000\u1a5f\u1a60\u0003\u000f"+ + "\u0007\u0000\u1a60\u04b2\u0001\u0000\u0000\u0000\u1a61\u1a62\u0003-\u0016"+ + "\u0000\u1a62\u1a63\u0003\u000f\u0007\u0000\u1a63\u1a64\u0003\u001f\u000f"+ + "\u0000\u1a64\u1a65\u0003%\u0012\u0000\u1a65\u04b4\u0001\u0000\u0000\u0000"+ + "\u1a66\u1a67\u0003-\u0016\u0000\u1a67\u1a68\u0003\u000f\u0007\u0000\u1a68"+ + "\u1a69\u0003\u001f\u000f\u0000\u1a69\u1a6a\u0003%\u0012\u0000\u1a6a\u1a6b"+ + "\u0003\u001d\u000e\u0000\u1a6b\u1a6c\u0003\u0007\u0003\u0000\u1a6c\u1a6d"+ + "\u0003-\u0016\u0000\u1a6d\u1a6e\u0003\u000f\u0007\u0000\u1a6e\u04b6\u0001"+ + "\u0000\u0000\u0000\u1a6f\u1a70\u0003-\u0016\u0000\u1a70\u1a71\u0003\u000f"+ + "\u0007\u0000\u1a71\u1a72\u0003\u001f\u000f\u0000\u1a72\u1a73\u0003%\u0012"+ + "\u0000\u1a73\u1a74\u0003#\u0011\u0000\u1a74\u1a75\u0003)\u0014\u0000\u1a75"+ + "\u1a76\u0003\u0007\u0003\u0000\u1a76\u1a77\u0003)\u0014\u0000\u1a77\u1a78"+ + "\u00037\u001b\u0000\u1a78\u04b8\u0001\u0000\u0000\u0000\u1a79\u1a7a\u0003"+ + "-\u0016\u0000\u1a7a\u1a7b\u0003\u000f\u0007\u0000\u1a7b\u1a7c\u0003)\u0014"+ + "\u0000\u1a7c\u1a7d\u0003\u001f\u000f\u0000\u1a7d\u1a7e\u0003\u0017\u000b"+ + "\u0000\u1a7e\u1a7f\u0003!\u0010\u0000\u1a7f\u1a80\u0003\u0007\u0003\u0000"+ + "\u1a80\u1a81\u0003-\u0016\u0000\u1a81\u1a82\u0003\u000f\u0007\u0000\u1a82"+ + "\u04ba\u0001\u0000\u0000\u0000\u1a83\u1a84\u0003-\u0016\u0000\u1a84\u1a85"+ + "\u0003\u0015\n\u0000\u1a85\u1a86\u0003\u0007\u0003\u0000\u1a86\u1a87\u0003"+ + "!\u0010\u0000\u1a87\u04bc\u0001\u0000\u0000\u0000\u1a88\u1a89\u0003-\u0016"+ + "\u0000\u1a89\u1a8a\u0003\u0015\n\u0000\u1a8a\u1a8b\u0003\u000f\u0007\u0000"+ + "\u1a8b\u1a8c\u0003!\u0010\u0000\u1a8c\u04be\u0001\u0000\u0000\u0000\u1a8d"+ + "\u1a8e\u0003-\u0016\u0000\u1a8e\u1a8f\u0003\u0017\u000b\u0000\u1a8f\u1a90"+ + "\u0003\u000f\u0007\u0000\u1a90\u1a91\u0003+\u0015\u0000\u1a91\u04c0\u0001"+ + "\u0000\u0000\u0000\u1a92\u1a93\u0003-\u0016\u0000\u1a93\u1a94\u0003\u0017"+ + "\u000b\u0000\u1a94\u1a95\u0003\u001f\u000f\u0000\u1a95\u1a96\u0003\u000f"+ + "\u0007\u0000\u1a96\u04c2\u0001\u0000\u0000\u0000\u1a97\u1a98\u0003-\u0016"+ + "\u0000\u1a98\u1a99\u0003\u0017\u000b\u0000\u1a99\u1a9a\u0003\u001f\u000f"+ + "\u0000\u1a9a\u1a9b\u0003\u000f\u0007\u0000\u1a9b\u1a9c\u0003+\u0015\u0000"+ + "\u1a9c\u1a9d\u0003-\u0016\u0000\u1a9d\u1a9e\u0003\u0007\u0003\u0000\u1a9e"+ + "\u1a9f\u0003\u001f\u000f\u0000\u1a9f\u1aa0\u0003%\u0012\u0000\u1aa0\u04c4"+ + "\u0001\u0000\u0000\u0000\u1aa1\u1aa2\u0003-\u0016\u0000\u1aa2\u1aa3\u0003"+ + "\u0017\u000b\u0000\u1aa3\u1aa4\u0003\u001f\u000f\u0000\u1aa4\u1aa5\u0003"+ + "\u000f\u0007\u0000\u1aa5\u1aa6\u00039\u001c\u0000\u1aa6\u1aa7\u0003#\u0011"+ + "\u0000\u1aa7\u1aa8\u0003!\u0010\u0000\u1aa8\u1aa9\u0003\u000f\u0007\u0000"+ + "\u1aa9\u1aaa\u0005_\u0000\u0000\u1aaa\u1aab\u0003\u0015\n\u0000\u1aab"+ + "\u1aac\u0003#\u0011\u0000\u1aac\u1aad\u0003/\u0017\u0000\u1aad\u1aae\u0003"+ + ")\u0014\u0000\u1aae\u04c6\u0001\u0000\u0000\u0000\u1aaf\u1ab0\u0003-\u0016"+ + "\u0000\u1ab0\u1ab1\u0003\u0017\u000b\u0000\u1ab1\u1ab2\u0003\u001f\u000f"+ + "\u0000\u1ab2\u1ab3\u0003\u000f\u0007\u0000\u1ab3\u1ab4\u00039\u001c\u0000"+ + "\u1ab4\u1ab5\u0003#\u0011\u0000\u1ab5\u1ab6\u0003!\u0010\u0000\u1ab6\u1ab7"+ + "\u0003\u000f\u0007\u0000\u1ab7\u1ab8\u0005_\u0000\u0000\u1ab8\u1ab9\u0003"+ + "\u001f\u000f\u0000\u1ab9\u1aba\u0003\u0017\u000b\u0000\u1aba\u1abb\u0003"+ + "!\u0010\u0000\u1abb\u1abc\u0003/\u0017\u0000\u1abc\u1abd\u0003-\u0016"+ + "\u0000\u1abd\u1abe\u0003\u000f\u0007\u0000\u1abe\u04c8\u0001\u0000\u0000"+ + "\u0000\u1abf\u1ac0\u0003-\u0016\u0000\u1ac0\u1ac1\u0003\u0017\u000b\u0000"+ + "\u1ac1\u1ac2\u0003\u001f\u000f\u0000\u1ac2\u1ac3\u0003\u0017\u000b\u0000"+ + "\u1ac3\u1ac4\u0003!\u0010\u0000\u1ac4\u1ac5\u0003\u0013\t\u0000\u1ac5"+ + "\u04ca\u0001\u0000\u0000\u0000\u1ac6\u1ac7\u0003-\u0016\u0000\u1ac7\u1ac8"+ + "\u0003#\u0011\u0000\u1ac8\u04cc\u0001\u0000\u0000\u0000\u1ac9\u1aca\u0003"+ + "-\u0016\u0000\u1aca\u1acb\u0003#\u0011\u0000\u1acb\u1acc\u0003\u0007\u0003"+ + "\u0000\u1acc\u1acd\u0003+\u0015\u0000\u1acd\u1ace\u0003-\u0016\u0000\u1ace"+ + "\u04ce\u0001\u0000\u0000\u0000\u1acf\u1ad0\u0003-\u0016\u0000\u1ad0\u1ad1"+ + "\u0003#\u0011\u0000\u1ad1\u1ad2\u0003%\u0012\u0000\u1ad2\u1ad3\u0005_"+ + "\u0000\u0000\u1ad3\u1ad4\u0003\u001d\u000e\u0000\u1ad4\u1ad5\u0003\u000f"+ + "\u0007\u0000\u1ad5\u1ad6\u00031\u0018\u0000\u1ad6\u1ad7\u0003\u000f\u0007"+ + "\u0000\u1ad7\u1ad8\u0003\u001d\u000e\u0000\u1ad8\u1ad9\u0005_\u0000\u0000"+ + "\u1ad9\u1ada\u0003\u000b\u0005\u0000\u1ada\u1adb\u0003#\u0011\u0000\u1adb"+ + "\u1adc\u0003/\u0017\u0000\u1adc\u1add\u0003!\u0010\u0000\u1add\u1ade\u0003"+ + "-\u0016\u0000\u1ade\u04d0\u0001\u0000\u0000\u0000\u1adf\u1ae0\u0003-\u0016"+ + "\u0000\u1ae0\u1ae1\u0003)\u0014\u0000\u1ae1\u1ae2\u0003\u0007\u0003\u0000"+ + "\u1ae2\u1ae3\u0003\u0017\u000b\u0000\u1ae3\u1ae4\u0003\u001d\u000e\u0000"+ + "\u1ae4\u1ae5\u0003\u0017\u000b\u0000\u1ae5\u1ae6\u0003!\u0010\u0000\u1ae6"+ + "\u1ae7\u0003\u0013\t\u0000\u1ae7\u04d2\u0001\u0000\u0000\u0000\u1ae8\u1ae9"+ + "\u0003-\u0016\u0000\u1ae9\u1aea\u0003)\u0014\u0000\u1aea\u1aeb\u0003\u0007"+ + "\u0003\u0000\u1aeb\u1aec\u0003!\u0010\u0000\u1aec\u1aed\u0003+\u0015\u0000"+ + "\u1aed\u1aee\u0003\u0007\u0003\u0000\u1aee\u1aef\u0003\u000b\u0005\u0000"+ + "\u1aef\u1af0\u0003-\u0016\u0000\u1af0\u1af1\u0003\u0017\u000b\u0000\u1af1"+ + "\u1af2\u0003#\u0011\u0000\u1af2\u1af3\u0003!\u0010\u0000\u1af3\u04d4\u0001"+ + "\u0000\u0000\u0000\u1af4\u1af5\u0003-\u0016\u0000\u1af5\u1af6\u0003)\u0014"+ + "\u0000\u1af6\u1af7\u0003\u0007\u0003\u0000\u1af7\u1af8\u0003!\u0010\u0000"+ + "\u1af8\u1af9\u0003+\u0015\u0000\u1af9\u1afa\u0003\u0007\u0003\u0000\u1afa"+ + "\u1afb\u0003\u000b\u0005\u0000\u1afb\u1afc\u0003-\u0016\u0000\u1afc\u1afd"+ + "\u0003\u0017\u000b\u0000\u1afd\u1afe\u0003#\u0011\u0000\u1afe\u1aff\u0003"+ + "!\u0010\u0000\u1aff\u1b00\u0005_\u0000\u0000\u1b00\u1b01\u0003\u0007\u0003"+ + "\u0000\u1b01\u1b02\u0003\u000b\u0005\u0000\u1b02\u1b03\u0003-\u0016\u0000"+ + "\u1b03\u1b04\u0003\u0017\u000b\u0000\u1b04\u1b05\u00031\u0018\u0000\u1b05"+ + "\u1b06\u0003\u000f\u0007\u0000\u1b06\u04d6\u0001\u0000\u0000\u0000\u1b07"+ + "\u1b08\u0003-\u0016\u0000\u1b08\u1b09\u0003)\u0014\u0000\u1b09\u1b0a\u0003"+ + "\u0007\u0003\u0000\u1b0a\u1b0b\u0003!\u0010\u0000\u1b0b\u1b0c\u0003+\u0015"+ + "\u0000\u1b0c\u1b0d\u0003\u0007\u0003\u0000\u1b0d\u1b0e\u0003\u000b\u0005"+ + "\u0000\u1b0e\u1b0f\u0003-\u0016\u0000\u1b0f\u1b10\u0003\u0017\u000b\u0000"+ + "\u1b10\u1b11\u0003#\u0011\u0000\u1b11\u1b12\u0003!\u0010\u0000\u1b12\u1b13"+ + "\u0003+\u0015\u0000\u1b13\u1b14\u0005_\u0000\u0000\u1b14\u1b15\u0003\u000b"+ + "\u0005\u0000\u1b15\u1b16\u0003#\u0011\u0000\u1b16\u1b17\u0003\u001f\u000f"+ + "\u0000\u1b17\u1b18\u0003\u001f\u000f\u0000\u1b18\u1b19\u0003\u0017\u000b"+ + "\u0000\u1b19\u1b1a\u0003-\u0016\u0000\u1b1a\u1b1b\u0003-\u0016\u0000\u1b1b"+ + "\u1b1c\u0003\u000f\u0007\u0000\u1b1c\u1b1d\u0003\r\u0006\u0000\u1b1d\u04d8"+ + "\u0001\u0000\u0000\u0000\u1b1e\u1b1f\u0003-\u0016\u0000\u1b1f\u1b20\u0003"+ + ")\u0014\u0000\u1b20\u1b21\u0003\u0007\u0003\u0000\u1b21\u1b22\u0003!\u0010"+ + "\u0000\u1b22\u1b23\u0003+\u0015\u0000\u1b23\u1b24\u0003\u0007\u0003\u0000"+ + "\u1b24\u1b25\u0003\u000b\u0005\u0000\u1b25\u1b26\u0003-\u0016\u0000\u1b26"+ + "\u1b27\u0003\u0017\u000b\u0000\u1b27\u1b28\u0003#\u0011\u0000\u1b28\u1b29"+ + "\u0003!\u0010\u0000\u1b29\u1b2a\u0003+\u0015\u0000\u1b2a\u1b2b\u0005_"+ + "\u0000\u0000\u1b2b\u1b2c\u0003)\u0014\u0000\u1b2c\u1b2d\u0003#\u0011\u0000"+ + "\u1b2d\u1b2e\u0003\u001d\u000e\u0000\u1b2e\u1b2f\u0003\u001d\u000e\u0000"+ + "\u1b2f\u1b30\u0003\u000f\u0007\u0000\u1b30\u1b31\u0003\r\u0006\u0000\u1b31"+ + "\u1b32\u0005_\u0000\u0000\u1b32\u1b33\u0003\t\u0004\u0000\u1b33\u1b34"+ + "\u0003\u0007\u0003\u0000\u1b34\u1b35\u0003\u000b\u0005\u0000\u1b35\u1b36"+ + "\u0003\u001b\r\u0000\u1b36\u04da\u0001\u0000\u0000\u0000\u1b37\u1b38\u0003"+ + "-\u0016\u0000\u1b38\u1b39\u0003)\u0014\u0000\u1b39\u1b3a\u0003\u0007\u0003"+ + "\u0000\u1b3a\u1b3b\u0003!\u0010\u0000\u1b3b\u1b3c\u0003+\u0015\u0000\u1b3c"+ + "\u1b3d\u0003\u0011\b\u0000\u1b3d\u1b3e\u0003#\u0011\u0000\u1b3e\u1b3f"+ + "\u0003)\u0014\u0000\u1b3f\u1b40\u0003\u001f\u000f\u0000\u1b40\u04dc\u0001"+ + "\u0000\u0000\u0000\u1b41\u1b42\u0003-\u0016\u0000\u1b42\u1b43\u0003)\u0014"+ + "\u0000\u1b43\u1b44\u0003\u0007\u0003\u0000\u1b44\u1b45\u0003!\u0010\u0000"+ + "\u1b45\u1b46\u0003+\u0015\u0000\u1b46\u1b47\u0003\u0011\b\u0000\u1b47"+ + "\u1b48\u0003#\u0011\u0000\u1b48\u1b49\u0003)\u0014\u0000\u1b49\u1b4a\u0003"+ + "\u001f\u000f\u0000\u1b4a\u1b4b\u0003+\u0015\u0000\u1b4b\u04de\u0001\u0000"+ + "\u0000\u0000\u1b4c\u1b4d\u0003-\u0016\u0000\u1b4d\u1b4e\u0003)\u0014\u0000"+ + "\u1b4e\u1b4f\u0003\u0007\u0003\u0000\u1b4f\u1b50\u0003!\u0010\u0000\u1b50"+ + "\u1b51\u0003+\u0015\u0000\u1b51\u1b52\u0003\u001d\u000e\u0000\u1b52\u1b53"+ + "\u0003\u0007\u0003\u0000\u1b53\u1b54\u0003-\u0016\u0000\u1b54\u1b55\u0003"+ + "\u000f\u0007\u0000\u1b55\u04e0\u0001\u0000\u0000\u0000\u1b56\u1b57\u0003"+ + "-\u0016\u0000\u1b57\u1b58\u0003)\u0014\u0000\u1b58\u1b59\u0003\u0007\u0003"+ + "\u0000\u1b59\u1b5a\u0003!\u0010\u0000\u1b5a\u1b5b\u0003+\u0015\u0000\u1b5b"+ + "\u1b5c\u0003\u001d\u000e\u0000\u1b5c\u1b5d\u0003\u0007\u0003\u0000\u1b5d"+ + "\u1b5e\u0003-\u0016\u0000\u1b5e\u1b5f\u0003\u0017\u000b\u0000\u1b5f\u1b60"+ + "\u0003#\u0011\u0000\u1b60\u1b61\u0003!\u0010\u0000\u1b61\u04e2\u0001\u0000"+ + "\u0000\u0000\u1b62\u1b63\u0003-\u0016\u0000\u1b63\u1b64\u0003)\u0014\u0000"+ + "\u1b64\u1b65\u0003\u000f\u0007\u0000\u1b65\u1b66\u0003\u0007\u0003\u0000"+ + "\u1b66\u1b67\u0003-\u0016\u0000\u1b67\u04e4\u0001\u0000\u0000\u0000\u1b68"+ + "\u1b69\u0003-\u0016\u0000\u1b69\u1b6a\u0003)\u0014\u0000\u1b6a\u1b6b\u0003"+ + "\u0017\u000b\u0000\u1b6b\u1b6c\u0003\u0013\t\u0000\u1b6c\u1b6d\u0003\u0013"+ + "\t\u0000\u1b6d\u1b6e\u0003\u000f\u0007\u0000\u1b6e\u1b6f\u0003)\u0014"+ + "\u0000\u1b6f\u04e6\u0001\u0000\u0000\u0000\u1b70\u1b71\u0003-\u0016\u0000"+ + "\u1b71\u1b72\u0003)\u0014\u0000\u1b72\u1b73\u0003\u0017\u000b\u0000\u1b73"+ + "\u1b74\u0003\u0013\t\u0000\u1b74\u1b75\u0003\u0013\t\u0000\u1b75\u1b76"+ + "\u0003\u000f\u0007\u0000\u1b76\u1b77\u0003)\u0014\u0000\u1b77\u1b78\u0005"+ + "_\u0000\u0000\u1b78\u1b79\u0003\u000b\u0005\u0000\u1b79\u1b7a\u0003\u0007"+ + "\u0003\u0000\u1b7a\u1b7b\u0003-\u0016\u0000\u1b7b\u1b7c\u0003\u0007\u0003"+ + "\u0000\u1b7c\u1b7d\u0003\u001d\u000e\u0000\u1b7d\u1b7e\u0003#\u0011\u0000"+ + "\u1b7e\u1b7f\u0003\u0013\t\u0000\u1b7f\u04e8\u0001\u0000\u0000\u0000\u1b80"+ + "\u1b81\u0003-\u0016\u0000\u1b81\u1b82\u0003)\u0014\u0000\u1b82\u1b83\u0003"+ + "\u0017\u000b\u0000\u1b83\u1b84\u0003\u0013\t\u0000\u1b84\u1b85\u0003\u0013"+ + "\t\u0000\u1b85\u1b86\u0003\u000f\u0007\u0000\u1b86\u1b87\u0003)\u0014"+ + "\u0000\u1b87\u1b88\u0005_\u0000\u0000\u1b88\u1b89\u0003!\u0010\u0000\u1b89"+ + "\u1b8a\u0003\u0007\u0003\u0000\u1b8a\u1b8b\u0003\u001f\u000f\u0000\u1b8b"+ + "\u1b8c\u0003\u000f\u0007\u0000\u1b8c\u04ea\u0001\u0000\u0000\u0000\u1b8d"+ + "\u1b8e\u0003-\u0016\u0000\u1b8e\u1b8f\u0003)\u0014\u0000\u1b8f\u1b90\u0003"+ + "\u0017\u000b\u0000\u1b90\u1b91\u0003\u0013\t\u0000\u1b91\u1b92\u0003\u0013"+ + "\t\u0000\u1b92\u1b93\u0003\u000f\u0007\u0000\u1b93\u1b94\u0003)\u0014"+ + "\u0000\u1b94\u1b95\u0005_\u0000\u0000\u1b95\u1b96\u0003+\u0015\u0000\u1b96"+ + "\u1b97\u0003\u000b\u0005\u0000\u1b97\u1b98\u0003\u0015\n\u0000\u1b98\u1b99"+ + "\u0003\u000f\u0007\u0000\u1b99\u1b9a\u0003\u001f\u000f\u0000\u1b9a\u1b9b"+ + "\u0003\u0007\u0003\u0000\u1b9b\u04ec\u0001\u0000\u0000\u0000\u1b9c\u1b9d"+ + "\u0003-\u0016\u0000\u1b9d\u1b9e\u0003)\u0014\u0000\u1b9e\u1b9f\u0003\u0017"+ + "\u000b\u0000\u1b9f\u1ba0\u0003\u001f\u000f\u0000\u1ba0\u04ee\u0001\u0000"+ + "\u0000\u0000\u1ba1\u1ba2\u0003-\u0016\u0000\u1ba2\u1ba3\u0003)\u0014\u0000"+ + "\u1ba3\u1ba4\u0003/\u0017\u0000\u1ba4\u1ba5\u0003\u000f\u0007\u0000\u1ba5"+ + "\u04f0\u0001\u0000\u0000\u0000\u1ba6\u1ba7\u0003-\u0016\u0000\u1ba7\u1ba8"+ + "\u0003)\u0014\u0000\u1ba8\u1ba9\u0003/\u0017\u0000\u1ba9\u1baa\u0003!"+ + "\u0010\u0000\u1baa\u1bab\u0003\u000b\u0005\u0000\u1bab\u1bac\u0003\u0007"+ + "\u0003\u0000\u1bac\u1bad\u0003-\u0016\u0000\u1bad\u1bae\u0003\u000f\u0007"+ + "\u0000\u1bae\u04f2\u0001\u0000\u0000\u0000\u1baf\u1bb0\u0003-\u0016\u0000"+ + "\u1bb0\u1bb1\u0003)\u0014\u0000\u1bb1\u1bb2\u0003/\u0017\u0000\u1bb2\u1bb3"+ + "\u0003+\u0015\u0000\u1bb3\u1bb4\u0003-\u0016\u0000\u1bb4\u1bb5\u0003\u000f"+ + "\u0007\u0000\u1bb5\u1bb6\u0003\r\u0006\u0000\u1bb6\u04f4\u0001\u0000\u0000"+ + "\u0000\u1bb7\u1bb8\u0003-\u0016\u0000\u1bb8\u1bb9\u00037\u001b\u0000\u1bb9"+ + "\u1bba\u0003%\u0012\u0000\u1bba\u1bbb\u0003\u000f\u0007\u0000\u1bbb\u04f6"+ + "\u0001\u0000\u0000\u0000\u1bbc\u1bbd\u0003/\u0017\u0000\u1bbd\u1bbe\u0003"+ + "\u000f\u0007\u0000\u1bbe\u1bbf\u0003+\u0015\u0000\u1bbf\u1bc0\u0003\u000b"+ + "\u0005\u0000\u1bc0\u1bc1\u0003\u0007\u0003\u0000\u1bc1\u1bc2\u0003%\u0012"+ + "\u0000\u1bc2\u1bc3\u0003\u000f\u0007\u0000\u1bc3\u04f8\u0001\u0000\u0000"+ + "\u0000\u1bc4\u1bc5\u0003/\u0017\u0000\u1bc5\u1bc6\u0003!\u0010\u0000\u1bc6"+ + "\u1bc7\u0003\t\u0004\u0000\u1bc7\u1bc8\u0003#\u0011\u0000\u1bc8\u1bc9"+ + "\u0003/\u0017\u0000\u1bc9\u1bca\u0003!\u0010\u0000\u1bca\u1bcb\u0003\r"+ + "\u0006\u0000\u1bcb\u1bcc\u0003\u000f\u0007\u0000\u1bcc\u1bcd\u0003\r\u0006"+ + "\u0000\u1bcd\u04fa\u0001\u0000\u0000\u0000\u1bce\u1bcf\u0003/\u0017\u0000"+ + "\u1bcf\u1bd0\u0003!\u0010\u0000\u1bd0\u1bd1\u0003\u000b\u0005\u0000\u1bd1"+ + "\u1bd2\u0003#\u0011\u0000\u1bd2\u1bd3\u0003\u001f\u000f\u0000\u1bd3\u1bd4"+ + "\u0003\u001f\u000f\u0000\u1bd4\u1bd5\u0003\u0017\u000b\u0000\u1bd5\u1bd6"+ + "\u0003-\u0016\u0000\u1bd6\u1bd7\u0003-\u0016\u0000\u1bd7\u1bd8\u0003\u000f"+ + "\u0007\u0000\u1bd8\u1bd9\u0003\r\u0006\u0000\u1bd9\u04fc\u0001\u0000\u0000"+ + "\u0000\u1bda\u1bdb\u0003/\u0017\u0000\u1bdb\u1bdc\u0003!\u0010\u0000\u1bdc"+ + "\u1bdd\u0003\r\u0006\u0000\u1bdd\u1bde\u0003\u000f\u0007\u0000\u1bde\u1bdf"+ + "\u0003)\u0014\u0000\u1bdf\u04fe\u0001\u0000\u0000\u0000\u1be0\u1be1\u0003"+ + "/\u0017\u0000\u1be1\u1be2\u0003!\u0010\u0000\u1be2\u1be3\u0003\u000f\u0007"+ + "\u0000\u1be3\u1be4\u0003!\u0010\u0000\u1be4\u1be5\u0003\u000b\u0005\u0000"+ + "\u1be5\u1be6\u0003)\u0014\u0000\u1be6\u1be7\u00037\u001b\u0000\u1be7\u1be8"+ + "\u0003%\u0012\u0000\u1be8\u1be9\u0003-\u0016\u0000\u1be9\u1bea\u0003\u000f"+ + "\u0007\u0000\u1bea\u1beb\u0003\r\u0006\u0000\u1beb\u0500\u0001\u0000\u0000"+ + "\u0000\u1bec\u1bed\u0003/\u0017\u0000\u1bed\u1bee\u0003!\u0010\u0000\u1bee"+ + "\u1bef\u0003\u0017\u000b\u0000\u1bef\u1bf0\u0003#\u0011\u0000\u1bf0\u1bf1"+ + "\u0003!\u0010\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\'\u0013\u0000\u1bf6\u1bf7\u0003/\u0017\u0000"+ + "\u1bf7\u1bf8\u0003\u000f\u0007\u0000\u1bf8\u0504\u0001\u0000\u0000\u0000"+ + "\u1bf9\u1bfa\u0003/\u0017\u0000\u1bfa\u1bfb\u0003!\u0010\u0000\u1bfb\u1bfc"+ + "\u0003\u001b\r\u0000\u1bfc\u1bfd\u0003!\u0010\u0000\u1bfd\u1bfe\u0003"+ + "#\u0011\u0000\u1bfe\u1bff\u00033\u0019\u0000\u1bff\u1c00\u0003!\u0010"+ + "\u0000\u1c00\u0506\u0001\u0000\u0000\u0000\u1c01\u1c02\u0003/\u0017\u0000"+ + "\u1c02\u1c03\u0003!\u0010\u0000\u1c03\u1c04\u0003\u001d\u000e\u0000\u1c04"+ + "\u1c05\u0003\u0017\u000b\u0000\u1c05\u1c06\u0003+\u0015\u0000\u1c06\u1c07"+ + "\u0003-\u0016\u0000\u1c07\u1c08\u0003\u000f\u0007\u0000\u1c08\u1c09\u0003"+ + "!\u0010\u0000\u1c09\u0508\u0001\u0000\u0000\u0000\u1c0a\u1c0b\u0003/\u0017"+ + "\u0000\u1c0b\u1c0c\u0003!\u0010\u0000\u1c0c\u1c0d\u0003\u001d\u000e\u0000"+ + "\u1c0d\u1c0e\u0003#\u0011\u0000\u1c0e\u1c0f\u0003\u0013\t\u0000\u1c0f"+ + "\u1c10\u0003\u0013\t\u0000\u1c10\u1c11\u0003\u000f\u0007\u0000\u1c11\u1c12"+ + "\u0003\r\u0006\u0000\u1c12\u050a\u0001\u0000\u0000\u0000\u1c13\u1c14\u0003"+ + "/\u0017\u0000\u1c14\u1c15\u0003!\u0010\u0000\u1c15\u1c16\u0003!\u0010"+ + "\u0000\u1c16\u1c17\u0003\u0007\u0003\u0000\u1c17\u1c18\u0003\u001f\u000f"+ + "\u0000\u1c18\u1c19\u0003\u000f\u0007\u0000\u1c19\u1c1a\u0003\r\u0006\u0000"+ + "\u1c1a\u050c\u0001\u0000\u0000\u0000\u1c1b\u1c1c\u0003/\u0017\u0000\u1c1c"+ + "\u1c1d\u0003!\u0010\u0000\u1c1d\u1c1e\u0003!\u0010\u0000\u1c1e\u1c1f\u0003"+ + "\u000f\u0007\u0000\u1c1f\u1c20\u0003+\u0015\u0000\u1c20\u1c21\u0003-\u0016"+ + "\u0000\u1c21\u050e\u0001\u0000\u0000\u0000\u1c22\u1c23\u0003/\u0017\u0000"+ + "\u1c23\u1c24\u0003!\u0010\u0000\u1c24\u1c25\u0003-\u0016\u0000\u1c25\u1c26"+ + "\u0003\u0017\u000b\u0000\u1c26\u1c27\u0003\u001d\u000e\u0000\u1c27\u0510"+ + "\u0001\u0000\u0000\u0000\u1c28\u1c29\u0003/\u0017\u0000\u1c29\u1c2a\u0003"+ + "%\u0012\u0000\u1c2a\u1c2b\u0003\r\u0006\u0000\u1c2b\u1c2c\u0003\u0007"+ + "\u0003\u0000\u1c2c\u1c2d\u0003-\u0016\u0000\u1c2d\u1c2e\u0003\u000f\u0007"+ + "\u0000\u1c2e\u0512\u0001\u0000\u0000\u0000\u1c2f\u1c30\u0003/\u0017\u0000"+ + "\u1c30\u1c31\u0003%\u0012\u0000\u1c31\u1c32\u0003%\u0012\u0000\u1c32\u1c33"+ + "\u0003\u000f\u0007\u0000\u1c33\u1c34\u0003)\u0014\u0000\u1c34\u0514\u0001"+ + "\u0000\u0000\u0000\u1c35\u1c36\u0003/\u0017\u0000\u1c36\u1c37\u0003+\u0015"+ + "\u0000\u1c37\u1c38\u0003\u0007\u0003\u0000\u1c38\u1c39\u0003\u0013\t\u0000"+ + "\u1c39\u1c3a\u0003\u000f\u0007\u0000\u1c3a\u0516\u0001\u0000\u0000\u0000"+ + "\u1c3b\u1c3c\u0003/\u0017\u0000\u1c3c\u1c3d\u0003+\u0015\u0000\u1c3d\u1c3e"+ + "\u0003\u000f\u0007\u0000\u1c3e\u1c3f\u0003)\u0014\u0000\u1c3f\u0518\u0001"+ + "\u0000\u0000\u0000\u1c40\u1c41\u0003/\u0017\u0000\u1c41\u1c42\u0003+\u0015"+ + "\u0000\u1c42\u1c43\u0003\u000f\u0007\u0000\u1c43\u1c44\u0003)\u0014\u0000"+ + "\u1c44\u1c45\u0005_\u0000\u0000\u1c45\u1c46\u0003\r\u0006\u0000\u1c46"+ + "\u1c47\u0003\u000f\u0007\u0000\u1c47\u1c48\u0003\u0011\b\u0000\u1c48\u1c49"+ + "\u0003\u0017\u000b\u0000\u1c49\u1c4a\u0003!\u0010\u0000\u1c4a\u1c4b\u0003"+ + "\u000f\u0007\u0000\u1c4b\u1c4c\u0003\r\u0006\u0000\u1c4c\u1c4d\u0005_"+ + "\u0000\u0000\u1c4d\u1c4e\u0003-\u0016\u0000\u1c4e\u1c4f\u00037\u001b\u0000"+ + "\u1c4f\u1c50\u0003%\u0012\u0000\u1c50\u1c51\u0003\u000f\u0007\u0000\u1c51"+ + "\u1c52\u0005_\u0000\u0000\u1c52\u1c53\u0003\u000b\u0005\u0000\u1c53\u1c54"+ + "\u0003\u0007\u0003\u0000\u1c54\u1c55\u0003-\u0016\u0000\u1c55\u1c56\u0003"+ + "\u0007\u0003\u0000\u1c56\u1c57\u0003\u001d\u000e\u0000\u1c57\u1c58\u0003"+ + "#\u0011\u0000\u1c58\u1c59\u0003\u0013\t\u0000\u1c59\u051a\u0001\u0000"+ + "\u0000\u0000\u1c5a\u1c5b\u0003/\u0017\u0000\u1c5b\u1c5c\u0003+\u0015\u0000"+ + "\u1c5c\u1c5d\u0003\u000f\u0007\u0000\u1c5d\u1c5e\u0003)\u0014\u0000\u1c5e"+ + "\u1c5f\u0005_\u0000\u0000\u1c5f\u1c60\u0003\r\u0006\u0000\u1c60\u1c61"+ + "\u0003\u000f\u0007\u0000\u1c61\u1c62\u0003\u0011\b\u0000\u1c62\u1c63\u0003"+ + "\u0017\u000b\u0000\u1c63\u1c64\u0003!\u0010\u0000\u1c64\u1c65\u0003\u000f"+ + "\u0007\u0000\u1c65\u1c66\u0003\r\u0006\u0000\u1c66\u1c67\u0005_\u0000"+ + "\u0000\u1c67\u1c68\u0003-\u0016\u0000\u1c68\u1c69\u00037\u001b\u0000\u1c69"+ + "\u1c6a\u0003%\u0012\u0000\u1c6a\u1c6b\u0003\u000f\u0007\u0000\u1c6b\u1c6c"+ + "\u0005_\u0000\u0000\u1c6c\u1c6d\u0003\u000b\u0005\u0000\u1c6d\u1c6e\u0003"+ + "#\u0011\u0000\u1c6e\u1c6f\u0003\r\u0006\u0000\u1c6f\u1c70\u0003\u000f"+ + "\u0007\u0000\u1c70\u051c\u0001\u0000\u0000\u0000\u1c71\u1c72\u0003/\u0017"+ + "\u0000\u1c72\u1c73\u0003+\u0015\u0000\u1c73\u1c74\u0003\u000f\u0007\u0000"+ + "\u1c74\u1c75\u0003)\u0014\u0000\u1c75\u1c76\u0005_\u0000\u0000\u1c76\u1c77"+ + "\u0003\r\u0006\u0000\u1c77\u1c78\u0003\u000f\u0007\u0000\u1c78\u1c79\u0003"+ + "\u0011\b\u0000\u1c79\u1c7a\u0003\u0017\u000b\u0000\u1c7a\u1c7b\u0003!"+ + "\u0010\u0000\u1c7b\u1c7c\u0003\u000f\u0007\u0000\u1c7c\u1c7d\u0003\r\u0006"+ + "\u0000\u1c7d\u1c7e\u0005_\u0000\u0000\u1c7e\u1c7f\u0003-\u0016\u0000\u1c7f"+ + "\u1c80\u00037\u001b\u0000\u1c80\u1c81\u0003%\u0012\u0000\u1c81\u1c82\u0003"+ + "\u000f\u0007\u0000\u1c82\u1c83\u0005_\u0000\u0000\u1c83\u1c84\u0003!\u0010"+ + "\u0000\u1c84\u1c85\u0003\u0007\u0003\u0000\u1c85\u1c86\u0003\u001f\u000f"+ + "\u0000\u1c86\u1c87\u0003\u000f\u0007\u0000\u1c87\u051e\u0001\u0000\u0000"+ + "\u0000\u1c88\u1c89\u0003/\u0017\u0000\u1c89\u1c8a\u0003+\u0015\u0000\u1c8a"+ + "\u1c8b\u0003\u000f\u0007\u0000\u1c8b\u1c8c\u0003)\u0014\u0000\u1c8c\u1c8d"+ + "\u0005_\u0000\u0000\u1c8d\u1c8e\u0003\r\u0006\u0000\u1c8e\u1c8f\u0003"+ + "\u000f\u0007\u0000\u1c8f\u1c90\u0003\u0011\b\u0000\u1c90\u1c91\u0003\u0017"+ + "\u000b\u0000\u1c91\u1c92\u0003!\u0010\u0000\u1c92\u1c93\u0003\u000f\u0007"+ + "\u0000\u1c93\u1c94\u0003\r\u0006\u0000\u1c94\u1c95\u0005_\u0000\u0000"+ + "\u1c95\u1c96\u0003-\u0016\u0000\u1c96\u1c97\u00037\u001b\u0000\u1c97\u1c98"+ + "\u0003%\u0012\u0000\u1c98\u1c99\u0003\u000f\u0007\u0000\u1c99\u1c9a\u0005"+ + "_\u0000\u0000\u1c9a\u1c9b\u0003+\u0015\u0000\u1c9b\u1c9c\u0003\u000b\u0005"+ + "\u0000\u1c9c\u1c9d\u0003\u0015\n\u0000\u1c9d\u1c9e\u0003\u000f\u0007\u0000"+ + "\u1c9e\u1c9f\u0003\u001f\u000f\u0000\u1c9f\u1ca0\u0003\u0007\u0003\u0000"+ + "\u1ca0\u0520\u0001\u0000\u0000\u0000\u1ca1\u1ca2\u0003/\u0017\u0000\u1ca2"+ + "\u1ca3\u0003+\u0015\u0000\u1ca3\u1ca4\u0003\u0017\u000b\u0000\u1ca4\u1ca5"+ + "\u0003!\u0010\u0000\u1ca5\u1ca6\u0003\u0013\t\u0000\u1ca6\u0522\u0001"+ + "\u0000\u0000\u0000\u1ca7\u1ca8\u00031\u0018\u0000\u1ca8\u1ca9\u0003\u0007"+ + "\u0003\u0000\u1ca9\u1caa\u0003\u000b\u0005\u0000\u1caa\u1cab\u0003/\u0017"+ + "\u0000\u1cab\u1cac\u0003/\u0017\u0000\u1cac\u1cad\u0003\u001f\u000f\u0000"+ + "\u1cad\u0524\u0001\u0000\u0000\u0000\u1cae\u1caf\u00031\u0018\u0000\u1caf"+ + "\u1cb0\u0003\u0007\u0003\u0000\u1cb0\u1cb1\u0003\u001d\u000e\u0000\u1cb1"+ + "\u1cb2\u0003\u0017\u000b\u0000\u1cb2\u1cb3\u0003\r\u0006\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\u1cba\u0003\u0007"+ + "\u0003\u0000\u1cba\u1cbb\u0003-\u0016\u0000\u1cbb\u1cbc\u0003\u000f\u0007"+ + "\u0000\u1cbc\u0528\u0001\u0000\u0000\u0000\u1cbd\u1cbe\u00031\u0018\u0000"+ + "\u1cbe\u1cbf\u0003\u0007\u0003\u0000\u1cbf\u1cc0\u0003\u001d\u000e\u0000"+ + "\u1cc0\u1cc1\u0003\u0017\u000b\u0000\u1cc1\u1cc2\u0003\r\u0006\u0000\u1cc2"+ + "\u1cc3\u0003\u0007\u0003\u0000\u1cc3\u1cc4\u0003-\u0016\u0000\u1cc4\u1cc5"+ + "\u0003#\u0011\u0000\u1cc5\u1cc6\u0003)\u0014\u0000\u1cc6\u052a\u0001\u0000"+ + "\u0000\u0000\u1cc7\u1cc8\u00031\u0018\u0000\u1cc8\u1cc9\u0003\u0007\u0003"+ + "\u0000\u1cc9\u1cca\u0003\u001d\u000e\u0000\u1cca\u1ccb\u0003/\u0017\u0000"+ + "\u1ccb\u1ccc\u0003\u000f\u0007\u0000\u1ccc\u052c\u0001\u0000\u0000\u0000"+ + "\u1ccd\u1cce\u00031\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\u1cd3\u0003+\u0015\u0000\u1cd3\u052e\u0001"+ + "\u0000\u0000\u0000\u1cd4\u1cd5\u00031\u0018\u0000\u1cd5\u1cd6\u0003\u0007"+ + "\u0003\u0000\u1cd6\u1cd7\u0003)\u0014\u0000\u1cd7\u1cd8\u0005_\u0000\u0000"+ + "\u1cd8\u1cd9\u0003%\u0012\u0000\u1cd9\u1cda\u0003#\u0011\u0000\u1cda\u1cdb"+ + "\u0003%\u0012\u0000\u1cdb\u0530\u0001\u0000\u0000\u0000\u1cdc\u1cdd\u0003"+ + "1\u0018\u0000\u1cdd\u1cde\u0003\u0007\u0003\u0000\u1cde\u1cdf\u0003)\u0014"+ + "\u0000\u1cdf\u1ce0\u0005_\u0000\u0000\u1ce0\u1ce1\u0003+\u0015\u0000\u1ce1"+ + "\u1ce2\u0003\u0007\u0003\u0000\u1ce2\u1ce3\u0003\u001f\u000f\u0000\u1ce3"+ + "\u1ce4\u0003%\u0012\u0000\u1ce4\u0532\u0001\u0000\u0000\u0000\u1ce5\u1ce6"+ + "\u00031\u0018\u0000\u1ce6\u1ce7\u0003\u0007\u0003\u0000\u1ce7\u1ce8\u0003"+ + ")\u0014\u0000\u1ce8\u1ce9\u0003\u000b\u0005\u0000\u1ce9\u1cea\u0003\u0015"+ + "\n\u0000\u1cea\u1ceb\u0003\u0007\u0003\u0000\u1ceb\u1cec\u0003)\u0014"+ + "\u0000\u1cec\u0534\u0001\u0000\u0000\u0000\u1ced\u1cee\u00031\u0018\u0000"+ + "\u1cee\u1cef\u0003\u0007\u0003\u0000\u1cef\u1cf0\u0003)\u0014\u0000\u1cf0"+ + "\u1cf1\u0003\u0017\u000b\u0000\u1cf1\u1cf2\u0003\u0007\u0003\u0000\u1cf2"+ + "\u1cf3\u0003\t\u0004\u0000\u1cf3\u1cf4\u0003\u001d\u000e\u0000\u1cf4\u1cf5"+ + "\u0003\u000f\u0007\u0000\u1cf5\u0536\u0001\u0000\u0000\u0000\u1cf6\u1cf7"+ + "\u00031\u0018\u0000\u1cf7\u1cf8\u0003\u0007\u0003\u0000\u1cf8\u1cf9\u0003"+ + ")\u0014\u0000\u1cf9\u1cfa\u0003\u0017\u000b\u0000\u1cfa\u1cfb\u0003\u0007"+ + "\u0003\u0000\u1cfb\u1cfc\u0003\r\u0006\u0000\u1cfc\u1cfd\u0003\u0017\u000b"+ + "\u0000\u1cfd\u1cfe\u0003\u000b\u0005\u0000\u1cfe\u0538\u0001\u0000\u0000"+ + "\u0000\u1cff\u1d00\u00031\u0018\u0000\u1d00\u1d01\u0003\u0007\u0003\u0000"+ + "\u1d01\u1d02\u0003)\u0014\u0000\u1d02\u1d03\u00037\u001b\u0000\u1d03\u1d04"+ + "\u0003\u0017\u000b\u0000\u1d04\u1d05\u0003!\u0010\u0000\u1d05\u1d06\u0003"+ + "\u0013\t\u0000\u1d06\u053a\u0001\u0000\u0000\u0000\u1d07\u1d08\u00031"+ + "\u0018\u0000\u1d08\u1d09\u0003\u000f\u0007\u0000\u1d09\u1d0a\u0003)\u0014"+ + "\u0000\u1d0a\u1d0b\u0003\t\u0004\u0000\u1d0b\u1d0c\u0003#\u0011\u0000"+ + "\u1d0c\u1d0d\u0003+\u0015\u0000\u1d0d\u1d0e\u0003\u000f\u0007\u0000\u1d0e"+ + "\u053c\u0001\u0000\u0000\u0000\u1d0f\u1d10\u00031\u0018\u0000\u1d10\u1d11"+ + "\u0003\u0017\u000b\u0000\u1d11\u1d12\u0003\u000f\u0007\u0000\u1d12\u1d13"+ + "\u00033\u0019\u0000\u1d13\u053e\u0001\u0000\u0000\u0000\u1d14\u1d15\u0003"+ + "1\u0018\u0000\u1d15\u1d16\u0003#\u0011\u0000\u1d16\u1d17\u0003\u001d\u000e"+ + "\u0000\u1d17\u1d18\u0003\u0007\u0003\u0000\u1d18\u1d19\u0003-\u0016\u0000"+ + "\u1d19\u1d1a\u0003\u0017\u000b\u0000\u1d1a\u1d1b\u0003\u001d\u000e\u0000"+ + "\u1d1b\u1d1c\u0003\u000f\u0007\u0000\u1d1c\u0540\u0001\u0000\u0000\u0000"+ + "\u1d1d\u1d1e\u00033\u0019\u0000\u1d1e\u1d1f\u0003\u0015\n\u0000\u1d1f"+ + "\u1d20\u0003\u000f\u0007\u0000\u1d20\u1d21\u0003!\u0010\u0000\u1d21\u0542"+ + "\u0001\u0000\u0000\u0000\u1d22\u1d23\u00033\u0019\u0000\u1d23\u1d24\u0003"+ + "\u0015\n\u0000\u1d24\u1d25\u0003\u000f\u0007\u0000\u1d25\u1d26\u0003!"+ + "\u0010\u0000\u1d26\u1d27\u0003\u000f\u0007\u0000\u1d27\u1d28\u00031\u0018"+ + "\u0000\u1d28\u1d29\u0003\u000f\u0007\u0000\u1d29\u1d2a\u0003)\u0014\u0000"+ + "\u1d2a\u0544\u0001\u0000\u0000\u0000\u1d2b\u1d2c\u00033\u0019\u0000\u1d2c"+ + "\u1d2d\u0003\u0015\n\u0000\u1d2d\u1d2e\u0003\u000f\u0007\u0000\u1d2e\u1d2f"+ + "\u0003)\u0014\u0000\u1d2f\u1d30\u0003\u000f\u0007\u0000\u1d30\u0546\u0001"+ + "\u0000\u0000\u0000\u1d31\u1d32\u00033\u0019\u0000\u1d32\u1d33\u0003\u0017"+ + "\u000b\u0000\u1d33\u1d34\u0003\r\u0006\u0000\u1d34\u1d35\u0003-\u0016"+ + "\u0000\u1d35\u1d36\u0003\u0015\n\u0000\u1d36\u1d37\u0005_\u0000\u0000"+ + "\u1d37\u1d38\u0003\t\u0004\u0000\u1d38\u1d39\u0003/\u0017\u0000\u1d39"+ + "\u1d3a\u0003\u000b\u0005\u0000\u1d3a\u1d3b\u0003\u001b\r\u0000\u1d3b\u1d3c"+ + "\u0003\u000f\u0007\u0000\u1d3c\u1d3d\u0003-\u0016\u0000\u1d3d\u0548\u0001"+ + "\u0000\u0000\u0000\u1d3e\u1d3f\u00033\u0019\u0000\u1d3f\u1d40\u0003\u0017"+ + "\u000b\u0000\u1d40\u1d41\u0003!\u0010\u0000\u1d41\u1d42\u0003\r\u0006"+ + "\u0000\u1d42\u1d43\u0003#\u0011\u0000\u1d43\u1d44\u00033\u0019\u0000\u1d44"+ + "\u054a\u0001\u0000\u0000\u0000\u1d45\u1d46\u00033\u0019\u0000\u1d46\u1d47"+ + "\u0003\u0017\u000b\u0000\u1d47\u1d48\u0003-\u0016\u0000\u1d48\u1d49\u0003"+ + "\u0015\n\u0000\u1d49\u054c\u0001\u0000\u0000\u0000\u1d4a\u1d4b\u00033"+ + "\u0019\u0000\u1d4b\u1d4c\u0003\u0017\u000b\u0000\u1d4c\u1d4d\u0003-\u0016"+ + "\u0000\u1d4d\u1d4e\u0003\u0015\n\u0000\u1d4e\u1d4f\u0003\u0017\u000b\u0000"+ + "\u1d4f\u1d50\u0003!\u0010\u0000\u1d50\u054e\u0001\u0000\u0000\u0000\u1d51"+ + "\u1d52\u00033\u0019\u0000\u1d52\u1d53\u0003\u0017\u000b\u0000\u1d53\u1d54"+ + "\u0003-\u0016\u0000\u1d54\u1d55\u0003\u0015\n\u0000\u1d55\u1d56\u0003"+ + "#\u0011\u0000\u1d56\u1d57\u0003/\u0017\u0000\u1d57\u1d58\u0003-\u0016"+ + "\u0000\u1d58\u0550\u0001\u0000\u0000\u0000\u1d59\u1d5a\u00033\u0019\u0000"+ + "\u1d5a\u1d5b\u0003#\u0011\u0000\u1d5b\u1d5c\u0003)\u0014\u0000\u1d5c\u1d5d"+ + "\u0003\u001b\r\u0000\u1d5d\u0552\u0001\u0000\u0000\u0000\u1d5e\u1d5f\u0003"+ + "3\u0019\u0000\u1d5f\u1d60\u0003)\u0014\u0000\u1d60\u1d61\u0003\u0017\u000b"+ + "\u0000\u1d61\u1d62\u0003-\u0016\u0000\u1d62\u1d63\u0003\u000f\u0007\u0000"+ + "\u1d63\u0554\u0001\u0000\u0000\u0000\u1d64\u1d65\u00037\u001b\u0000\u1d65"+ + "\u1d66\u0003\u0007\u0003\u0000\u1d66\u1d67\u0003\u001f\u000f\u0000\u1d67"+ + "\u1d68\u0003\u001d\u000e\u0000\u1d68\u0556\u0001\u0000\u0000\u0000\u1d69"+ + "\u1d6a\u00037\u001b\u0000\u1d6a\u1d6b\u0003\u000f\u0007\u0000\u1d6b\u1d6c"+ + "\u0003\u0007\u0003\u0000\u1d6c\u1d6d\u0003)\u0014\u0000\u1d6d\u0558\u0001"+ + "\u0000\u0000\u0000\u1d6e\u1d6f\u00037\u001b\u0000\u1d6f\u1d70\u0003\u000f"+ + "\u0007\u0000\u1d70\u1d71\u0003+\u0015\u0000\u1d71\u055a\u0001\u0000\u0000"+ + "\u0000\u1d72\u1d73\u00039\u001c\u0000\u1d73\u1d74\u0003#\u0011\u0000\u1d74"+ + "\u1d75\u0003!\u0010\u0000\u1d75\u1d76\u0003\u000f\u0007\u0000\u1d76\u055c"+ + "\u0001\u0000\u0000\u0000\u1d77\u1d78\u0003+\u0015\u0000\u1d78\u1d79\u0003"+ + "/\u0017\u0000\u1d79\u1d7a\u0003%\u0012\u0000\u1d7a\u1d7b\u0003\u000f\u0007"+ + "\u0000\u1d7b\u1d7c\u0003)\u0014\u0000\u1d7c\u1d7d\u0003/\u0017\u0000\u1d7d"+ + "\u1d7e\u0003+\u0015\u0000\u1d7e\u1d7f\u0003\u000f\u0007\u0000\u1d7f\u1d80"+ + "\u0003)\u0014\u0000\u1d80\u055e\u0001\u0000\u0000\u0000\u1d81\u1d82\u0003"+ + "!\u0010\u0000\u1d82\u1d83\u0003#\u0011\u0000\u1d83\u1d84\u0003+\u0015"+ + "\u0000\u1d84\u1d85\u0003/\u0017\u0000\u1d85\u1d86\u0003%\u0012\u0000\u1d86"+ + "\u1d87\u0003\u000f\u0007\u0000\u1d87\u1d88\u0003)\u0014\u0000\u1d88\u1d89"+ + "\u0003/\u0017\u0000\u1d89\u1d8a\u0003+\u0015\u0000\u1d8a\u1d8b\u0003\u000f"+ + "\u0007\u0000\u1d8b\u1d8c\u0003)\u0014\u0000\u1d8c\u0560\u0001\u0000\u0000"+ + "\u0000\u1d8d\u1d8e\u0003\u000b\u0005\u0000\u1d8e\u1d8f\u0003)\u0014\u0000"+ + "\u1d8f\u1d90\u0003\u000f\u0007\u0000\u1d90\u1d91\u0003\u0007\u0003\u0000"+ + "\u1d91\u1d92\u0003-\u0016\u0000\u1d92\u1d93\u0003\u000f\u0007\u0000\u1d93"+ + "\u1d94\u0003)\u0014\u0000\u1d94\u1d95\u0003#\u0011\u0000\u1d95\u1d96\u0003"+ + "\u001d\u000e\u0000\u1d96\u1d97\u0003\u000f\u0007\u0000\u1d97\u0562\u0001"+ + "\u0000\u0000\u0000\u1d98\u1d99\u0003!\u0010\u0000\u1d99\u1d9a\u0003#\u0011"+ + "\u0000\u1d9a\u1d9b\u0003\u000b\u0005\u0000\u1d9b\u1d9c\u0003)\u0014\u0000"+ + "\u1d9c\u1d9d\u0003\u000f\u0007\u0000\u1d9d\u1d9e\u0003\u0007\u0003\u0000"+ + "\u1d9e\u1d9f\u0003-\u0016\u0000\u1d9f\u1da0\u0003\u000f\u0007\u0000\u1da0"+ + "\u1da1\u0003)\u0014\u0000\u1da1\u1da2\u0003#\u0011\u0000\u1da2\u1da3\u0003"+ + "\u001d\u000e\u0000\u1da3\u1da4\u0003\u000f\u0007\u0000\u1da4\u0564\u0001"+ + "\u0000\u0000\u0000\u1da5\u1da6\u0003\u0017\u000b\u0000\u1da6\u1da7\u0003"+ + "!\u0010\u0000\u1da7\u1da8\u0003\u0015\n\u0000\u1da8\u1da9\u0003\u000f"+ + "\u0007\u0000\u1da9\u1daa\u0003)\u0014\u0000\u1daa\u1dab\u0003\u0017\u000b"+ + "\u0000\u1dab\u1dac\u0003-\u0016\u0000\u1dac\u0566\u0001\u0000\u0000\u0000"+ + "\u1dad\u1dae\u0003!\u0010\u0000\u1dae\u1daf\u0003#\u0011\u0000\u1daf\u1db0"+ + "\u0003\u0017\u000b\u0000\u1db0\u1db1\u0003!\u0010\u0000\u1db1\u1db2\u0003"+ + "\u0015\n\u0000\u1db2\u1db3\u0003\u000f\u0007\u0000\u1db3\u1db4\u0003)"+ + "\u0014\u0000\u1db4\u1db5\u0003\u0017\u000b\u0000\u1db5\u1db6\u0003-\u0016"+ + "\u0000\u1db6\u0568\u0001\u0000\u0000\u0000\u1db7\u1db8\u0003\u001d\u000e"+ + "\u0000\u1db8\u1db9\u0003#\u0011\u0000\u1db9\u1dba\u0003\u0013\t\u0000"+ + "\u1dba\u1dbb\u0003\u0017\u000b\u0000\u1dbb\u1dbc\u0003!\u0010\u0000\u1dbc"+ + "\u056a\u0001\u0000\u0000\u0000\u1dbd\u1dbe\u0003!\u0010\u0000\u1dbe\u1dbf"+ + "\u0003#\u0011\u0000\u1dbf\u1dc0\u0003\u001d\u000e\u0000\u1dc0\u1dc1\u0003"+ + "#\u0011\u0000\u1dc1\u1dc2\u0003\u0013\t\u0000\u1dc2\u1dc3\u0003\u0017"+ + "\u000b\u0000\u1dc3\u1dc4\u0003!\u0010\u0000\u1dc4\u056c\u0001\u0000\u0000"+ + "\u0000\u1dc5\u1dc6\u0003)\u0014\u0000\u1dc6\u1dc7\u0003\u000f\u0007\u0000"+ + "\u1dc7\u1dc8\u0003%\u0012\u0000\u1dc8\u1dc9\u0003\u001d\u000e\u0000\u1dc9"+ + "\u1dca\u0003\u0017\u000b\u0000\u1dca\u1dcb\u0003\u000b\u0005\u0000\u1dcb"+ + "\u1dcc\u0003\u0007\u0003\u0000\u1dcc\u1dcd\u0003-\u0016\u0000\u1dcd\u1dce"+ + "\u0003\u0017\u000b\u0000\u1dce\u1dcf\u0003#\u0011\u0000\u1dcf\u1dd0\u0003"+ + "!\u0010\u0000\u1dd0\u056e\u0001\u0000\u0000\u0000\u1dd1\u1dd2\u0003!\u0010"+ + "\u0000\u1dd2\u1dd3\u0003#\u0011\u0000\u1dd3\u1dd4\u0003)\u0014\u0000\u1dd4"+ + "\u1dd5\u0003\u000f\u0007\u0000\u1dd5\u1dd6\u0003%\u0012\u0000\u1dd6\u1dd7"+ + "\u0003\u001d\u000e\u0000\u1dd7\u1dd8\u0003\u0017\u000b\u0000\u1dd8\u1dd9"+ + "\u0003\u000b\u0005\u0000\u1dd9\u1dda\u0003\u0007\u0003\u0000\u1dda\u1ddb"+ + "\u0003-\u0016\u0000\u1ddb\u1ddc\u0003\u0017\u000b\u0000\u1ddc\u1ddd\u0003"+ + "#\u0011\u0000\u1ddd\u1dde\u0003!\u0010\u0000\u1dde\u0570\u0001\u0000\u0000"+ + "\u0000\u1ddf\u1de0\u0003\t\u0004\u0000\u1de0\u1de1\u00037\u001b\u0000"+ + "\u1de1\u1de2\u0003%\u0012\u0000\u1de2\u1de3\u0003\u0007\u0003\u0000\u1de3"+ + "\u1de4\u0003+\u0015\u0000\u1de4\u1de5\u0003+\u0015\u0000\u1de5\u1de6\u0003"+ + ")\u0014\u0000\u1de6\u1de7\u0003\u001d\u000e\u0000\u1de7\u1de8\u0003+\u0015"+ + "\u0000\u1de8\u0572\u0001\u0000\u0000\u0000\u1de9\u1dea\u0003!\u0010\u0000"+ + "\u1dea\u1deb\u0003#\u0011\u0000\u1deb\u1dec\u0003\t\u0004\u0000\u1dec"+ + "\u1ded\u00037\u001b\u0000\u1ded\u1dee\u0003%\u0012\u0000\u1dee\u1def\u0003"+ + "\u0007\u0003\u0000\u1def\u1df0\u0003+\u0015\u0000\u1df0\u1df1\u0003+\u0015"+ + "\u0000\u1df1\u1df2\u0003)\u0014\u0000\u1df2\u1df3\u0003\u001d\u000e\u0000"+ + "\u1df3\u1df4\u0003+\u0015\u0000\u1df4\u0574\u0001\u0000\u0000\u0000\u1df5"+ + "\u1df6\u0003+\u0015\u0000\u1df6\u1df7\u0003\u0011\b\u0000\u1df7\u1df8"+ + "\u0003/\u0017\u0000\u1df8\u1df9\u0003!\u0010\u0000\u1df9\u1dfa\u0003\u000b"+ + "\u0005\u0000\u1dfa\u0576\u0001\u0000\u0000\u0000\u1dfb\u1dfc\u0003+\u0015"+ + "\u0000\u1dfc\u1dfd\u0003-\u0016\u0000\u1dfd\u1dfe\u00037\u001b\u0000\u1dfe"+ + "\u1dff\u0003%\u0012\u0000\u1dff\u1e00\u0003\u000f\u0007\u0000\u1e00\u0578"+ + "\u0001\u0000\u0000\u0000\u1e01\u1e02\u0003+\u0015\u0000\u1e02\u1e03\u0003"+ + "+\u0015\u0000\u1e03\u1e04\u0003%\u0012\u0000\u1e04\u1e05\u0003\u0007\u0003"+ + "\u0000\u1e05\u1e06\u0003\u000b\u0005\u0000\u1e06\u1e07\u0003\u000f\u0007"+ + "\u0000\u1e07\u057a\u0001\u0000\u0000\u0000\u1e08\u1e09\u0003\u0011\b\u0000"+ + "\u1e09\u1e0a\u0003\u0017\u000b\u0000\u1e0a\u1e0b\u0003!\u0010\u0000\u1e0b"+ + "\u1e0c\u0003\u0007\u0003\u0000\u1e0c\u1e0d\u0003\u001d\u000e\u0000\u1e0d"+ + "\u1e0e\u0003\u0011\b\u0000\u1e0e\u1e0f\u0003/\u0017\u0000\u1e0f\u1e10"+ + "\u0003!\u0010\u0000\u1e10\u1e11\u0003\u000b\u0005\u0000\u1e11\u057c\u0001"+ + "\u0000\u0000\u0000\u1e12\u1e13\u0003\u0011\b\u0000\u1e13\u1e14\u0003\u0017"+ + "\u000b\u0000\u1e14\u1e15\u0003!\u0010\u0000\u1e15\u1e16\u0003\u0007\u0003"+ + "\u0000\u1e16\u1e17\u0003\u001d\u000e\u0000\u1e17\u1e18\u0003\u0011\b\u0000"+ + "\u1e18\u1e19"; + private static final String _serializedATNSegment3 = + "\u0003/\u0017\u0000\u1e19\u1e1a\u0003!\u0010\u0000\u1e1a\u1e1b\u0003\u000b"+ + "\u0005\u0000\u1e1b\u1e1c\u0005_\u0000\u0000\u1e1c\u1e1d\u0003\u000f\u0007"+ + "\u0000\u1e1d\u1e1e\u00035\u001a\u0000\u1e1e\u1e1f\u0003-\u0016\u0000\u1e1f"+ + "\u1e20\u0003)\u0014\u0000\u1e20\u1e21\u0003\u0007\u0003\u0000\u1e21\u057e"+ + "\u0001\u0000\u0000\u0000\u1e22\u1e23\u0003\u000b\u0005\u0000\u1e23\u1e24"+ + "\u0003#\u0011\u0000\u1e24\u1e25\u0003\u001f\u000f\u0000\u1e25\u1e26\u0003"+ + "\t\u0004\u0000\u1e26\u1e27\u0003\u0017\u000b\u0000\u1e27\u1e28\u0003!"+ + "\u0010\u0000\u1e28\u1e29\u0003\u000f\u0007\u0000\u1e29\u1e2a\u0003\u0011"+ + "\b\u0000\u1e2a\u1e2b\u0003/\u0017\u0000\u1e2b\u1e2c\u0003!\u0010\u0000"+ + "\u1e2c\u1e2d\u0003\u000b\u0005\u0000\u1e2d\u0580\u0001\u0000\u0000\u0000"+ + "\u1e2e\u1e2f\u0003+\u0015\u0000\u1e2f\u1e30\u0003\u000f\u0007\u0000\u1e30"+ + "\u1e31\u0003)\u0014\u0000\u1e31\u1e32\u0003\u0017\u000b\u0000\u1e32\u1e33"+ + "\u0003\u0007\u0003\u0000\u1e33\u1e34\u0003\u001d\u000e\u0000\u1e34\u1e35"+ + "\u0003\u0011\b\u0000\u1e35\u1e36\u0003/\u0017\u0000\u1e36\u1e37\u0003"+ + "!\u0010\u0000\u1e37\u1e38\u0003\u000b\u0005\u0000\u1e38\u0582\u0001\u0000"+ + "\u0000\u0000\u1e39\u1e3a\u0003\r\u0006\u0000\u1e3a\u1e3b\u0003\u000f\u0007"+ + "\u0000\u1e3b\u1e3c\u0003+\u0015\u0000\u1e3c\u1e3d\u0003\u000f\u0007\u0000"+ + "\u1e3d\u1e3e\u0003)\u0014\u0000\u1e3e\u1e3f\u0003\u0017\u000b\u0000\u1e3f"+ + "\u1e40\u0003\u0007\u0003\u0000\u1e40\u1e41\u0003\u001d\u000e\u0000\u1e41"+ + "\u1e42\u0003\u0011\b\u0000\u1e42\u1e43\u0003/\u0017\u0000\u1e43\u1e44"+ + "\u0003!\u0010\u0000\u1e44\u1e45\u0003\u000b\u0005\u0000\u1e45\u0584\u0001"+ + "\u0000\u0000\u0000\u1e46\u1e47\u0003\u0017\u000b\u0000\u1e47\u1e48\u0003"+ + "!\u0010\u0000\u1e48\u1e49\u0003\u0017\u000b\u0000\u1e49\u1e4a\u0003-\u0016"+ + "\u0000\u1e4a\u1e4b\u0003\u000b\u0005\u0000\u1e4b\u1e4c\u0003#\u0011\u0000"+ + "\u1e4c\u1e4d\u0003!\u0010\u0000\u1e4d\u1e4e\u0003\r\u0006\u0000\u1e4e"+ + "\u0586\u0001\u0000\u0000\u0000\u1e4f\u1e50\u0003\u001f\u000f\u0000\u1e50"+ + "\u1e51\u0003+\u0015\u0000\u1e51\u1e52\u0003\u0011\b\u0000\u1e52\u1e53"+ + "\u0003/\u0017\u0000\u1e53\u1e54\u0003!\u0010\u0000\u1e54\u1e55\u0003\u000b"+ + "\u0005\u0000\u1e55\u0588\u0001\u0000\u0000\u0000\u1e56\u1e57\u0003\u001f"+ + "\u000f\u0000\u1e57\u1e58\u0003\u0017\u000b\u0000\u1e58\u1e59\u0003!\u0010"+ + "\u0000\u1e59\u1e5a\u00031\u0018\u0000\u1e5a\u1e5b\u0003\u0011\b\u0000"+ + "\u1e5b\u1e5c\u0003/\u0017\u0000\u1e5c\u1e5d\u0003!\u0010\u0000\u1e5d\u1e5e"+ + "\u0003\u000b\u0005\u0000\u1e5e\u058a\u0001\u0000\u0000\u0000\u1e5f\u1e60"+ + "\u0003\u001f\u000f\u0000\u1e60\u1e61\u0003+\u0015\u0000\u1e61\u1e62\u0003"+ + "-\u0016\u0000\u1e62\u1e63\u00037\u001b\u0000\u1e63\u1e64\u0003%\u0012"+ + "\u0000\u1e64\u1e65\u0003\u000f\u0007\u0000\u1e65\u058c\u0001\u0000\u0000"+ + "\u0000\u1e66\u1e67\u0003\u001f\u000f\u0000\u1e67\u1e68\u0003+\u0015\u0000"+ + "\u1e68\u1e69\u0003+\u0015\u0000\u1e69\u1e6a\u0003%\u0012\u0000\u1e6a\u1e6b"+ + "\u0003\u0007\u0003\u0000\u1e6b\u1e6c\u0003\u000b\u0005\u0000\u1e6c\u1e6d"+ + "\u0003\u000f\u0007\u0000\u1e6d\u058e\u0001\u0000\u0000\u0000\u1e6e\u1e6f"+ + "\u0003\u001f\u000f\u0000\u1e6f\u1e70\u0003\u0011\b\u0000\u1e70\u1e71\u0003"+ + "\u0017\u000b\u0000\u1e71\u1e72\u0003!\u0010\u0000\u1e72\u1e73\u0003\u0007"+ + "\u0003\u0000\u1e73\u1e74\u0003\u001d\u000e\u0000\u1e74\u1e75\u0003\u0011"+ + "\b\u0000\u1e75\u1e76\u0003/\u0017\u0000\u1e76\u1e77\u0003!\u0010\u0000"+ + "\u1e77\u1e78\u0003\u000b\u0005\u0000\u1e78\u0590\u0001\u0000\u0000\u0000"+ + "\u1e79\u1e7a\u0003\u001f\u000f\u0000\u1e7a\u1e7b\u0003\u0011\b\u0000\u1e7b"+ + "\u1e7c\u0003\u0017\u000b\u0000\u1e7c\u1e7d\u0003!\u0010\u0000\u1e7d\u1e7e"+ + "\u0003\u0007\u0003\u0000\u1e7e\u1e7f\u0003\u001d\u000e\u0000\u1e7f\u1e80"+ + "\u0003\u0011\b\u0000\u1e80\u1e81\u0003/\u0017\u0000\u1e81\u1e82\u0003"+ + "!\u0010\u0000\u1e82\u1e83\u0003\u000b\u0005\u0000\u1e83\u1e84\u0005_\u0000"+ + "\u0000\u1e84\u1e85\u0003\u000f\u0007\u0000\u1e85\u1e86\u00035\u001a\u0000"+ + "\u1e86\u1e87\u0003-\u0016\u0000\u1e87\u1e88\u0003)\u0014\u0000\u1e88\u1e89"+ + "\u0003\u0007\u0003\u0000\u1e89\u0592\u0001\u0000\u0000\u0000\u1e8a\u1e8b"+ + "\u0003\u001f\u000f\u0000\u1e8b\u1e8c\u0003\u0017\u000b\u0000\u1e8c\u1e8d"+ + "\u0003!\u0010\u0000\u1e8d\u1e8e\u0003\u0017\u000b\u0000\u1e8e\u1e8f\u0003"+ + "-\u0016\u0000\u1e8f\u1e90\u0003\u000b\u0005\u0000\u1e90\u1e91\u0003#\u0011"+ + "\u0000\u1e91\u1e92\u0003!\u0010\u0000\u1e92\u1e93\u0003\r\u0006\u0000"+ + "\u1e93\u0594\u0001\u0000\u0000\u0000\u1e94\u1e95\u0003+\u0015\u0000\u1e95"+ + "\u1e96\u0003#\u0011\u0000\u1e96\u1e97\u0003)\u0014\u0000\u1e97\u1e98\u0003"+ + "-\u0016\u0000\u1e98\u1e99\u0003#\u0011\u0000\u1e99\u1e9a\u0003%\u0012"+ + "\u0000\u1e9a\u0596\u0001\u0000\u0000\u0000\u1e9b\u1e9c\u0003%\u0012\u0000"+ + "\u1e9c\u1e9d\u0003\u0007\u0003\u0000\u1e9d\u1e9e\u0003)\u0014\u0000\u1e9e"+ + "\u1e9f\u0003\u0007\u0003\u0000\u1e9f\u1ea0\u0003\u001d\u000e\u0000\u1ea0"+ + "\u1ea1\u0003\u001d\u000e\u0000\u1ea1\u1ea2\u0003\u000f\u0007\u0000\u1ea2"+ + "\u1ea3\u0003\u001d\u000e\u0000\u1ea3\u0598\u0001\u0000\u0000\u0000\u1ea4"+ + "\u1ea5\u0003\u0015\n\u0000\u1ea5\u1ea6\u00037\u001b\u0000\u1ea6\u1ea7"+ + "\u0003%\u0012\u0000\u1ea7\u1ea8\u0003#\u0011\u0000\u1ea8\u1ea9\u0003-"+ + "\u0016\u0000\u1ea9\u1eaa\u0003\u0015\n\u0000\u1eaa\u1eab\u0003\u000f\u0007"+ + "\u0000\u1eab\u1eac\u0003-\u0016\u0000\u1eac\u1ead\u0003\u0017\u000b\u0000"+ + "\u1ead\u1eae\u0003\u000b\u0005\u0000\u1eae\u1eaf\u0003\u0007\u0003\u0000"+ + "\u1eaf\u1eb0\u0003\u001d\u000e\u0000\u1eb0\u059a\u0001\u0000\u0000\u0000"+ + "\u1eb1\u1eb2\u0003+\u0015\u0000\u1eb2\u1eb3\u0003\u0007\u0003\u0000\u1eb3"+ + "\u1eb4\u0003\u0011\b\u0000\u1eb4\u1eb5\u0003\u000f\u0007\u0000\u1eb5\u059c"+ + "\u0001\u0000\u0000\u0000\u1eb6\u1eb7\u0003)\u0014\u0000\u1eb7\u1eb8\u0003"+ + "\u000f\u0007\u0000\u1eb8\u1eb9\u0003+\u0015\u0000\u1eb9\u1eba\u0003-\u0016"+ + "\u0000\u1eba\u1ebb\u0003)\u0014\u0000\u1ebb\u1ebc\u0003\u0017\u000b\u0000"+ + "\u1ebc\u1ebd\u0003\u000b\u0005\u0000\u1ebd\u1ebe\u0003-\u0016\u0000\u1ebe"+ + "\u1ebf\u0003\u000f\u0007\u0000\u1ebf\u1ec0\u0003\r\u0006\u0000\u1ec0\u059e"+ + "\u0001\u0000\u0000\u0000\u1ec1\u1ec2\u0003/\u0017\u0000\u1ec2\u1ec3\u0003"+ + "!\u0010\u0000\u1ec3\u1ec4\u0003+\u0015\u0000\u1ec4\u1ec5\u0003\u0007\u0003"+ + "\u0000\u1ec5\u1ec6\u0003\u0011\b\u0000\u1ec6\u1ec7\u0003\u000f\u0007\u0000"+ + "\u1ec7\u05a0\u0001\u0000\u0000\u0000\u1ec8\u1ec9\u0003\t\u0004\u0000\u1ec9"+ + "\u1eca\u0003\u0007\u0003\u0000\u1eca\u1ecb\u0003+\u0015\u0000\u1ecb\u1ecc"+ + "\u0003\u000f\u0007\u0000\u1ecc\u1ecd\u0003-\u0016\u0000\u1ecd\u1ece\u0003"+ + "7\u001b\u0000\u1ece\u1ecf\u0003%\u0012\u0000\u1ecf\u1ed0\u0003\u000f\u0007"+ + "\u0000\u1ed0\u05a2\u0001\u0000\u0000\u0000\u1ed1\u1ed2\u0003\u0017\u000b"+ + "\u0000\u1ed2\u1ed3\u0003\u0011\b\u0000\u1ed3\u05a4\u0001\u0000\u0000\u0000"+ + "\u1ed4\u1ed5\u0003\u001d\u000e\u0000\u1ed5\u1ed6\u0003#\u0011\u0000\u1ed6"+ + "\u1ed7\u0003\u000b\u0005\u0000\u1ed7\u1ed8\u0003\u0007\u0003\u0000\u1ed8"+ + "\u1ed9\u0003\u001d\u000e\u0000\u1ed9\u1eda\u0003\u000f\u0007\u0000\u1eda"+ + "\u05a6\u0001\u0000\u0000\u0000\u1edb\u1edc\u0003\u001d\u000e\u0000\u1edc"+ + "\u1edd\u0003\u000b\u0005\u0000\u1edd\u1ede\u0005_\u0000\u0000\u1ede\u1edf"+ + "\u0003\u000b\u0005\u0000\u1edf\u1ee0\u0003#\u0011\u0000\u1ee0\u1ee1\u0003"+ + "\u001d\u000e\u0000\u1ee1\u1ee2\u0003\u001d\u000e\u0000\u1ee2\u1ee3\u0003"+ + "\u0007\u0003\u0000\u1ee3\u1ee4\u0003-\u0016\u0000\u1ee4\u1ee5\u0003\u000f"+ + "\u0007\u0000\u1ee5\u05a8\u0001\u0000\u0000\u0000\u1ee6\u1ee7\u0003\u001d"+ + "\u000e\u0000\u1ee7\u1ee8\u0003\u000b\u0005\u0000\u1ee8\u1ee9\u0005_\u0000"+ + "\u0000\u1ee9\u1eea\u0003\u000b\u0005\u0000\u1eea\u1eeb\u0003-\u0016\u0000"+ + "\u1eeb\u1eec\u00037\u001b\u0000\u1eec\u1eed\u0003%\u0012\u0000\u1eed\u1eee"+ + "\u0003\u000f\u0007\u0000\u1eee\u05aa\u0001\u0000\u0000\u0000\u1eef\u1ef0"+ + "\u0003%\u0012\u0000\u1ef0\u1ef1\u0003)\u0014\u0000\u1ef1\u1ef2\u0003#"+ + "\u0011\u0000\u1ef2\u1ef3\u00031\u0018\u0000\u1ef3\u1ef4\u0003\u0017\u000b"+ + "\u0000\u1ef4\u1ef5\u0003\r\u0006\u0000\u1ef5\u1ef6\u0003\u000f\u0007\u0000"+ + "\u1ef6\u1ef7\u0003)\u0014\u0000\u1ef7\u05ac\u0001\u0000\u0000\u0000\u1ef8"+ + "\u1ef9\u00031\u0018\u0000\u1ef9\u1efa\u0003\u000f\u0007\u0000\u1efa\u1efb"+ + "\u0003)\u0014\u0000\u1efb\u1efc\u0003+\u0015\u0000\u1efc\u1efd\u0003\u0017"+ + "\u000b\u0000\u1efd\u1efe\u0003#\u0011\u0000\u1efe\u1eff\u0003!\u0010\u0000"+ + "\u1eff\u05ae\u0001\u0000\u0000\u0000\u1f00\u1f01\u0003\u0007\u0003\u0000"+ + "\u1f01\u1f02\u0003\u001d\u000e\u0000\u1f02\u1f03\u0003\u001d\u000e\u0000"+ + "\u1f03\u1f04\u0003#\u0011\u0000\u1f04\u1f05\u00033\u0019\u0000\u1f05\u1f06"+ + "\u0005_\u0000\u0000\u1f06\u1f07\u0003\u000b\u0005\u0000\u1f07\u1f08\u0003"+ + "#\u0011\u0000\u1f08\u1f09\u0003!\u0010\u0000\u1f09\u1f0a\u0003!\u0010"+ + "\u0000\u1f0a\u1f0b\u0003\u000f\u0007\u0000\u1f0b\u1f0c\u0003\u000b\u0005"+ + "\u0000\u1f0c\u1f0d\u0003-\u0016\u0000\u1f0d\u1f0e\u0003\u0017\u000b\u0000"+ + "\u1f0e\u1f0f\u0003#\u0011\u0000\u1f0f\u1f10\u0003!\u0010\u0000\u1f10\u1f11"+ + "\u0003+\u0015\u0000\u1f11\u05b0\u0001\u0000\u0000\u0000\u1f12\u1f13\u0003"+ + "\u0017\u000b\u0000\u1f13\u1f14\u0003+\u0015\u0000\u1f14\u1f15\u0005_\u0000"+ + "\u0000\u1f15\u1f16\u0003-\u0016\u0000\u1f16\u1f17\u0003\u000f\u0007\u0000"+ + "\u1f17\u1f18\u0003\u001f\u000f\u0000\u1f18\u1f19\u0003%\u0012\u0000\u1f19"+ + "\u1f1a\u0003\u001d\u000e\u0000\u1f1a\u1f1b\u0003\u0007\u0003\u0000\u1f1b"+ + "\u1f1c\u0003-\u0016\u0000\u1f1c\u1f1d\u0003\u000f\u0007\u0000\u1f1d\u05b2"+ + "\u0001\u0000\u0000\u0000\u1f1e\u1f1f\u0003\u000f\u0007\u0000\u1f1f\u1f20"+ + "\u00031\u0018\u0000\u1f20\u1f21\u0003\u000f\u0007\u0000\u1f21\u1f22\u0003"+ + "!\u0010\u0000\u1f22\u1f23\u0003-\u0016\u0000\u1f23\u05b4\u0001\u0000\u0000"+ + "\u0000\u1f24\u1f25\u00033\u0019\u0000\u1f25\u1f26\u0003)\u0014\u0000\u1f26"+ + "\u1f27\u0003\u0007\u0003\u0000\u1f27\u1f28\u0003%\u0012\u0000\u1f28\u1f29"+ + "\u0003%\u0012\u0000\u1f29\u1f2a\u0003\u000f\u0007\u0000\u1f2a\u1f2b\u0003"+ + ")\u0014\u0000\u1f2b\u05b6\u0001\u0000\u0000\u0000\u1f2c\u1f2d\u0003+\u0015"+ + "\u0000\u1f2d\u1f2e\u0003\u000f\u0007\u0000\u1f2e\u1f2f\u0003)\u0014\u0000"+ + "\u1f2f\u1f30\u00031\u0018\u0000\u1f30\u1f31\u0003\u000f\u0007\u0000\u1f31"+ + "\u1f32\u0003)\u0014\u0000\u1f32\u05b8\u0001\u0000\u0000\u0000\u1f33\u1f34"+ + "\u0003\t\u0004\u0000\u1f34\u1f35\u0003-\u0016\u0000\u1f35\u1f36\u0003"+ + ")\u0014\u0000\u1f36\u1f37\u0003\u000f\u0007\u0000\u1f37\u1f38\u0003\u000f"+ + "\u0007\u0000\u1f38\u05ba\u0001\u0000\u0000\u0000\u1f39\u1f3a\u0003\u0015"+ + "\n\u0000\u1f3a\u1f3b\u0003\u0007\u0003\u0000\u1f3b\u1f3c\u0003+\u0015"+ + "\u0000\u1f3c\u1f3d\u0003\u0015\n\u0000\u1f3d\u05bc\u0001\u0000\u0000\u0000"+ + "\u1f3e\u1f3f\u0003\u0013\t\u0000\u1f3f\u1f40\u0003\u0017\u000b\u0000\u1f40"+ + "\u1f41\u0003+\u0015\u0000\u1f41\u1f42\u0003-\u0016\u0000\u1f42\u05be\u0001"+ + "\u0000\u0000\u0000\u1f43\u1f44\u0003+\u0015\u0000\u1f44\u1f45\u0003%\u0012"+ + "\u0000\u1f45\u1f46\u0003\u0013\t\u0000\u1f46\u1f47\u0003\u0017\u000b\u0000"+ + "\u1f47\u1f48\u0003+\u0015\u0000\u1f48\u1f49\u0003-\u0016\u0000\u1f49\u05c0"+ + "\u0001\u0000\u0000\u0000\u1f4a\u1f4b\u0003\u0013\t\u0000\u1f4b\u1f4c\u0003"+ + "\u0017\u000b\u0000\u1f4c\u1f4d\u0003!\u0010\u0000\u1f4d\u05c2\u0001\u0000"+ + "\u0000\u0000\u1f4e\u1f4f\u0003\t\u0004\u0000\u1f4f\u1f50\u0003)\u0014"+ + "\u0000\u1f50\u1f51\u0003\u0017\u000b\u0000\u1f51\u1f52\u0003!\u0010\u0000"+ + "\u1f52\u05c4\u0001\u0000\u0000\u0000\u1f53\u1f54\u0003\u000b\u0005\u0000"+ + "\u1f54\u1f55\u0003#\u0011\u0000\u1f55\u1f56\u0003!\u0010\u0000\u1f56\u1f57"+ + "\u0003\u000b\u0005\u0000\u1f57\u1f58\u0003/\u0017\u0000\u1f58\u1f59\u0003"+ + ")\u0014\u0000\u1f59\u1f5a\u0003)\u0014\u0000\u1f5a\u1f5b\u0003\u000f\u0007"+ + "\u0000\u1f5b\u1f5c\u0003!\u0010\u0000\u1f5c\u1f5d\u0003-\u0016\u0000\u1f5d"+ + "\u1f5e\u0003\u001d\u000e\u0000\u1f5e\u1f5f\u00037\u001b\u0000\u1f5f\u05c6"+ + "\u0001\u0000\u0000\u0000\u1f60\u1f61\u0003\u0017\u000b\u0000\u1f61\u1f62"+ + "\u0003!\u0010\u0000\u1f62\u1f63\u0003\u001d\u000e\u0000\u1f63\u1f64\u0003"+ + "\u0017\u000b\u0000\u1f64\u1f65\u0003!\u0010\u0000\u1f65\u1f66\u0003\u000f"+ + "\u0007\u0000\u1f66\u05c8\u0001\u0000\u0000\u0000\u1f67\u1f68\u0003\u001f"+ + "\u000f\u0000\u1f68\u1f69\u0003\u0007\u0003\u0000\u1f69\u1f6a\u0003-\u0016"+ + "\u0000\u1f6a\u1f6b\u0003\u000f\u0007\u0000\u1f6b\u1f6c\u0003)\u0014\u0000"+ + "\u1f6c\u1f6d\u0003\u0017\u000b\u0000\u1f6d\u1f6e\u0003\u0007\u0003\u0000"+ + "\u1f6e\u1f6f\u0003\u001d\u000e\u0000\u1f6f\u1f70\u0003\u0017\u000b\u0000"+ + "\u1f70\u1f71\u00039\u001c\u0000\u1f71\u1f72\u0003\u000f\u0007\u0000\u1f72"+ + "\u1f73\u0003\r\u0006\u0000\u1f73\u05ca\u0001\u0000\u0000\u0000\u1f74\u1f75"+ + "\u0003\u001d\u000e\u0000\u1f75\u1f76\u0003\u000f\u0007\u0000\u1f76\u1f77"+ + "\u0003\u0011\b\u0000\u1f77\u1f78\u0003-\u0016\u0000\u1f78\u1f79\u0003"+ + "\u0007\u0003\u0000\u1f79\u1f7a\u0003)\u0014\u0000\u1f7a\u1f7b\u0003\u0013"+ + "\t\u0000\u1f7b\u05cc\u0001\u0000\u0000\u0000\u1f7c\u1f7d\u0003)\u0014"+ + "\u0000\u1f7d\u1f7e\u0003\u0017\u000b\u0000\u1f7e\u1f7f\u0003\u0013\t\u0000"+ + "\u1f7f\u1f80\u0003\u0015\n\u0000\u1f80\u1f81\u0003-\u0016\u0000\u1f81"+ + "\u1f82\u0003\u0007\u0003\u0000\u1f82\u1f83\u0003)\u0014\u0000\u1f83\u1f84"+ + "\u0003\u0013\t\u0000\u1f84\u05ce\u0001\u0000\u0000\u0000\u1f85\u1f86\u0003"+ + "\u000b\u0005\u0000\u1f86\u1f87\u0003#\u0011\u0000\u1f87\u1f88\u0003\u001f"+ + "\u000f\u0000\u1f88\u1f89\u0003\u001f\u000f\u0000\u1f89\u1f8a\u0003/\u0017"+ + "\u0000\u1f8a\u1f8b\u0003-\u0016\u0000\u1f8b\u1f8c\u0003\u0007\u0003\u0000"+ + "\u1f8c\u1f8d\u0003-\u0016\u0000\u1f8d\u1f8e\u0003#\u0011\u0000\u1f8e\u1f8f"+ + "\u0003)\u0014\u0000\u1f8f\u05d0\u0001\u0000\u0000\u0000\u1f90\u1f91\u0003"+ + "!\u0010\u0000\u1f91\u1f92\u0003\u000f\u0007\u0000\u1f92\u1f93\u0003\u0013"+ + "\t\u0000\u1f93\u1f94\u0003\u0007\u0003\u0000\u1f94\u1f95\u0003-\u0016"+ + "\u0000\u1f95\u1f96\u0003#\u0011\u0000\u1f96\u1f97\u0003)\u0014\u0000\u1f97"+ + "\u05d2\u0001\u0000\u0000\u0000\u1f98\u1f99\u0003\u0015\n\u0000\u1f99\u1f9a"+ + "\u0003\u0007\u0003\u0000\u1f9a\u1f9b\u0003+\u0015\u0000\u1f9b\u1f9c\u0003"+ + "\u0015\n\u0000\u1f9c\u1f9d\u0003\u000f\u0007\u0000\u1f9d\u1f9e\u0003+"+ + "\u0015\u0000\u1f9e\u05d4\u0001\u0000\u0000\u0000\u1f9f\u1fa0\u0003\u001f"+ + "\u000f\u0000\u1fa0\u1fa1\u0003\u000f\u0007\u0000\u1fa1\u1fa2\u0003)\u0014"+ + "\u0000\u1fa2\u1fa3\u0003\u0013\t\u0000\u1fa3\u1fa4\u0003\u000f\u0007\u0000"+ + "\u1fa4\u1fa5\u0003+\u0015\u0000\u1fa5\u05d6\u0001\u0000\u0000\u0000\u1fa6"+ + "\u1fa7\u0003\u0011\b\u0000\u1fa7\u1fa8\u0003\u0007\u0003\u0000\u1fa8\u1fa9"+ + "\u0003\u001f\u000f\u0000\u1fa9\u1faa\u0003\u0017\u000b\u0000\u1faa\u1fab"+ + "\u0003\u001d\u000e\u0000\u1fab\u1fac\u00037\u001b\u0000\u1fac\u05d8\u0001"+ + "\u0000\u0000\u0000\u1fad\u1fae\u0003%\u0012\u0000\u1fae\u1faf\u0003#\u0011"+ + "\u0000\u1faf\u1fb0\u0003\u001d\u000e\u0000\u1fb0\u1fb1\u0003\u0017\u000b"+ + "\u0000\u1fb1\u1fb2\u0003\u000b\u0005\u0000\u1fb2\u1fb3\u00037\u001b\u0000"+ + "\u1fb3\u05da\u0001\u0000\u0000\u0000\u1fb4\u1fb5\u0003#\u0011\u0000\u1fb5"+ + "\u1fb6\u00033\u0019\u0000\u1fb6\u1fb7\u0003!\u0010\u0000\u1fb7\u1fb8\u0003"+ + "\u000f\u0007\u0000\u1fb8\u1fb9\u0003\r\u0006\u0000\u1fb9\u05dc\u0001\u0000"+ + "\u0000\u0000\u1fba\u1fbb\u0003\u0007\u0003\u0000\u1fbb\u1fbc\u0003\t\u0004"+ + "\u0000\u1fbc\u1fbd\u0003+\u0015\u0000\u1fbd\u1fbe\u0003-\u0016\u0000\u1fbe"+ + "\u1fbf\u0003\u0017\u000b\u0000\u1fbf\u1fc0\u0003\u001f\u000f\u0000\u1fc0"+ + "\u1fc1\u0003\u000f\u0007\u0000\u1fc1\u05de\u0001\u0000\u0000\u0000\u1fc2"+ + "\u1fc3\u0003\t\u0004\u0000\u1fc3\u1fc4\u0003\u0017\u000b\u0000\u1fc4\u1fc5"+ + "\u0003\u0013\t\u0000\u1fc5\u1fc6\u0003+\u0015\u0000\u1fc6\u1fc7\u0003"+ + "\u000f\u0007\u0000\u1fc7\u1fc8\u0003)\u0014\u0000\u1fc8\u1fc9\u0003\u0017"+ + "\u000b\u0000\u1fc9\u1fca\u0003\u0007\u0003\u0000\u1fca\u1fcb\u0003\u001d"+ + "\u000e\u0000\u1fcb\u05e0\u0001\u0000\u0000\u0000\u1fcc\u1fcd\u0003\t\u0004"+ + "\u0000\u1fcd\u1fce\u0003\u0017\u000b\u0000\u1fce\u1fcf\u0003-\u0016\u0000"+ + "\u1fcf\u1fd0\u0005 \u0000\u0000\u1fd0\u1fd1\u00031\u0018\u0000\u1fd1\u1fd2"+ + "\u0003\u0007\u0003\u0000\u1fd2\u1fd3\u0003)\u0014\u0000\u1fd3\u1fd4\u0003"+ + "7\u001b\u0000\u1fd4\u1fd5\u0003\u0017\u000b\u0000\u1fd5\u1fd6\u0003!\u0010"+ + "\u0000\u1fd6\u1fd7\u0003\u0013\t\u0000\u1fd7\u05e2\u0001\u0000\u0000\u0000"+ + "\u1fd8\u1fd9\u0003\t\u0004\u0000\u1fd9\u1fda\u0003#\u0011\u0000\u1fda"+ + "\u1fdb\u0003#\u0011\u0000\u1fdb\u1fdc\u0003\u001d\u000e\u0000\u1fdc\u05e4"+ + "\u0001\u0000\u0000\u0000\u1fdd\u1fde\u0003\t\u0004\u0000\u1fde\u1fdf\u0003"+ + "#\u0011\u0000\u1fdf\u1fe0\u00035\u001a\u0000\u1fe0\u05e6\u0001\u0000\u0000"+ + "\u0000\u1fe1\u1fe2\u0003\t\u0004\u0000\u1fe2\u1fe3\u00037\u001b\u0000"+ + "\u1fe3\u1fe4\u0003-\u0016\u0000\u1fe4\u1fe5\u0003\u000f\u0007\u0000\u1fe5"+ + "\u1fe6\u0003\u0007\u0003\u0000\u1fe6\u05e8\u0001\u0000\u0000\u0000\u1fe7"+ + "\u1fe8\u0003\u000b\u0005\u0000\u1fe8\u1fe9\u0003\u0015\n\u0000\u1fe9\u1fea"+ + "\u0003\u0007\u0003\u0000\u1fea\u1feb\u0003)\u0014\u0000\u1feb\u1fec\u0003"+ + "\u0007\u0003\u0000\u1fec\u1fed\u0003\u000b\u0005\u0000\u1fed\u1fee\u0003"+ + "-\u0016\u0000\u1fee\u1fef\u0003\u000f\u0007\u0000\u1fef\u1ff0\u0003)\u0014"+ + "\u0000\u1ff0\u1ff1\u0005 \u0000\u0000\u1ff1\u1ff2\u00031\u0018\u0000\u1ff2"+ + "\u1ff3\u0003\u0007\u0003\u0000\u1ff3\u1ff4\u0003)\u0014\u0000\u1ff4\u1ff5"+ + "\u00037\u001b\u0000\u1ff5\u1ff6\u0003\u0017\u000b\u0000\u1ff6\u1ff7\u0003"+ + "!\u0010\u0000\u1ff7\u1ff8\u0003\u0013\t\u0000\u1ff8\u05ea\u0001\u0000"+ + "\u0000\u0000\u1ff9\u1ffa\u0003\u000b\u0005\u0000\u1ffa\u1ffb\u0003\u0017"+ + "\u000b\u0000\u1ffb\u1ffc\u0003\r\u0006\u0000\u1ffc\u1ffd\u0003)\u0014"+ + "\u0000\u1ffd\u05ec\u0001\u0000\u0000\u0000\u1ffe\u1fff\u0003\u000b\u0005"+ + "\u0000\u1fff\u2000\u0003\u0017\u000b\u0000\u2000\u2001\u0003)\u0014\u0000"+ + "\u2001\u2002\u0003\u000b\u0005\u0000\u2002\u2003\u0003\u001d\u000e\u0000"+ + "\u2003\u2004\u0003\u000f\u0007\u0000\u2004\u05ee\u0001\u0000\u0000\u0000"+ + "\u2005\u2006\u0003\u0011\b\u0000\u2006\u2007\u0003\u001d\u000e\u0000\u2007"+ + "\u2008\u0003#\u0011\u0000\u2008\u2009\u0003\u0007\u0003\u0000\u2009\u200a"+ + "\u0003-\u0016\u0000\u200a\u200b\u00054\u0000\u0000\u200b\u05f0\u0001\u0000"+ + "\u0000\u0000\u200c\u200d\u0003\u0011\b\u0000\u200d\u200e\u0003\u001d\u000e"+ + "\u0000\u200e\u200f\u0003#\u0011\u0000\u200f\u2010\u0003\u0007\u0003\u0000"+ + "\u2010\u2011\u0003-\u0016\u0000\u2011\u2012\u00058\u0000\u0000\u2012\u05f2"+ + "\u0001\u0000\u0000\u0000\u2013\u2014\u0003\u0017\u000b\u0000\u2014\u2015"+ + "\u0003!\u0010\u0000\u2015\u2016\u0003\u000f\u0007\u0000\u2016\u2017\u0003"+ + "-\u0016\u0000\u2017\u05f4\u0001\u0000\u0000\u0000\u2018\u2019\u0003\u0017"+ + "\u000b\u0000\u2019\u201a\u0003!\u0010\u0000\u201a\u201b\u0003-\u0016\u0000"+ + "\u201b\u201c\u00052\u0000\u0000\u201c\u05f6\u0001\u0000\u0000\u0000\u201d"+ + "\u201e\u0003\u0017\u000b\u0000\u201e\u201f\u0003!\u0010\u0000\u201f\u2020"+ + "\u0003-\u0016\u0000\u2020\u2021\u00054\u0000\u0000\u2021\u05f8\u0001\u0000"+ + "\u0000\u0000\u2022\u2023\u0003\u0017\u000b\u0000\u2023\u2024\u0003!\u0010"+ + "\u0000\u2024\u2025\u0003-\u0016\u0000\u2025\u2026\u00058\u0000\u0000\u2026"+ + "\u05fa\u0001\u0000\u0000\u0000\u2027\u2028\u0003\u0019\f\u0000\u2028\u2029"+ + "\u0003+\u0015\u0000\u2029\u202a\u0003#\u0011\u0000\u202a\u202b\u0003!"+ + "\u0010\u0000\u202b\u05fc\u0001\u0000\u0000\u0000\u202c\u202d\u0003\u0019"+ + "\f\u0000\u202d\u202e\u0003+\u0015\u0000\u202e\u202f\u0003#\u0011\u0000"+ + "\u202f\u2030\u0003!\u0010\u0000\u2030\u2031\u0003\t\u0004\u0000\u2031"+ + "\u05fe\u0001\u0000\u0000\u0000\u2032\u2033\u0003\u001d\u000e\u0000\u2033"+ + "\u2034\u0003\u0017\u000b\u0000\u2034\u2035\u0003!\u0010\u0000\u2035\u2036"+ + "\u0003\u000f\u0007\u0000\u2036\u0600\u0001\u0000\u0000\u0000\u2037\u2038"+ + "\u0003\u001d\u000e\u0000\u2038\u2039\u0003+\u0015\u0000\u2039\u203a\u0003"+ + "\u000f\u0007\u0000\u203a\u203b\u0003\u0013\t\u0000\u203b\u0602\u0001\u0000"+ + "\u0000\u0000\u203c\u203d\u0003\u001f\u000f\u0000\u203d\u203e\u0003\u0007"+ + "\u0003\u0000\u203e\u203f\u0003\u000b\u0005\u0000\u203f\u2040\u0003\u0007"+ + "\u0003\u0000\u2040\u2041\u0003\r\u0006\u0000\u2041\u2042\u0003\r\u0006"+ + "\u0000\u2042\u2043\u0003)\u0014\u0000\u2043\u0604\u0001\u0000\u0000\u0000"+ + "\u2044\u2045\u0003\u001f\u000f\u0000\u2045\u2046\u0003\u0007\u0003\u0000"+ + "\u2046\u2047\u0003\u000b\u0005\u0000\u2047\u2048\u0003\u0007\u0003\u0000"+ + "\u2048\u2049\u0003\r\u0006\u0000\u2049\u204a\u0003\r\u0006\u0000\u204a"+ + "\u204b\u0003)\u0014\u0000\u204b\u204c\u00058\u0000\u0000\u204c\u0606\u0001"+ + "\u0000\u0000\u0000\u204d\u204e\u0003\u001f\u000f\u0000\u204e\u204f\u0003"+ + "#\u0011\u0000\u204f\u2050\u0003!\u0010\u0000\u2050\u2051\u0003\u000f\u0007"+ + "\u0000\u2051\u2052\u00037\u001b\u0000\u2052\u0608\u0001\u0000\u0000\u0000"+ + "\u2053\u2054\u0003%\u0012\u0000\u2054\u2055\u0003\u0013\t\u0000\u2055"+ + "\u2056\u0005_\u0000\u0000\u2056\u2057\u0003\u001d\u000e\u0000\u2057\u2058"+ + "\u0003+\u0015\u0000\u2058\u2059\u0003!\u0010\u0000\u2059\u060a\u0001\u0000"+ + "\u0000\u0000\u205a\u205b\u0003%\u0012\u0000\u205b\u205c\u0003#\u0011\u0000"+ + "\u205c\u205d\u0003\u0017\u000b\u0000\u205d\u205e\u0003!\u0010\u0000\u205e"+ + "\u205f\u0003-\u0016\u0000\u205f\u060c\u0001\u0000\u0000\u0000\u2060\u2061"+ + "\u0003%\u0012\u0000\u2061\u2062\u0003#\u0011\u0000\u2062\u2063\u0003\u001d"+ + "\u000e\u0000\u2063\u2064\u00037\u001b\u0000\u2064\u2065\u0003\u0013\t"+ + "\u0000\u2065\u2066\u0003#\u0011\u0000\u2066\u2067\u0003!\u0010\u0000\u2067"+ + "\u060e\u0001\u0000\u0000\u0000\u2068\u2069\u0003)\u0014\u0000\u2069\u206a"+ + "\u0003\u000f\u0007\u0000\u206a\u206b\u0003\u001d\u000e\u0000\u206b\u206c"+ + "\u0003-\u0016\u0000\u206c\u206d\u0003\u0017\u000b\u0000\u206d\u206e\u0003"+ + "\u001f\u000f\u0000\u206e\u206f\u0003\u000f\u0007\u0000\u206f\u0610\u0001"+ + "\u0000\u0000\u0000\u2070\u2071\u0003+\u0015\u0000\u2071\u2072\u0003\u000f"+ + "\u0007\u0000\u2072\u2073\u0003)\u0014\u0000\u2073\u2074\u0003\u0017\u000b"+ + "\u0000\u2074\u2075\u0003\u0007\u0003\u0000\u2075\u2076\u0003\u001d\u000e"+ + "\u0000\u2076\u0612\u0001\u0000\u0000\u0000\u2077\u2078\u0003+\u0015\u0000"+ + "\u2078\u2079\u0003\u000f\u0007\u0000\u2079\u207a\u0003)\u0014\u0000\u207a"+ + "\u207b\u0003\u0017\u000b\u0000\u207b\u207c\u0003\u0007\u0003\u0000\u207c"+ + "\u207d\u0003\u001d\u000e\u0000\u207d\u207e\u00052\u0000\u0000\u207e\u0614"+ + "\u0001\u0000\u0000\u0000\u207f\u2080\u0003+\u0015\u0000\u2080\u2081\u0003"+ + "\u000f\u0007\u0000\u2081\u2082\u0003)\u0014\u0000\u2082\u2083\u0003\u0017"+ + "\u000b\u0000\u2083\u2084\u0003\u0007\u0003\u0000\u2084\u2085\u0003\u001d"+ + "\u000e\u0000\u2085\u2086\u00054\u0000\u0000\u2086\u0616\u0001\u0000\u0000"+ + "\u0000\u2087\u2088\u0003+\u0015\u0000\u2088\u2089\u0003\u000f\u0007\u0000"+ + "\u2089\u208a\u0003)\u0014\u0000\u208a\u208b\u0003\u0017\u000b\u0000\u208b"+ + "\u208c\u0003\u0007\u0003\u0000\u208c\u208d\u0003\u001d\u000e\u0000\u208d"+ + "\u208e\u00058\u0000\u0000\u208e\u0618\u0001\u0000\u0000\u0000\u208f\u2090"+ + "\u0003+\u0015\u0000\u2090\u2091\u0003\u001f\u000f\u0000\u2091\u2092\u0003"+ + "\u0007\u0003\u0000\u2092\u2093\u0003\u001d\u000e\u0000\u2093\u2094\u0003"+ + "\u001d\u000e\u0000\u2094\u2095\u0003+\u0015\u0000\u2095\u2096\u0003\u000f"+ + "\u0007\u0000\u2096\u2097\u0003)\u0014\u0000\u2097\u2098\u0003\u0017\u000b"+ + "\u0000\u2098\u2099\u0003\u0007\u0003\u0000\u2099\u209a\u0003\u001d\u000e"+ + "\u0000\u209a\u061a\u0001\u0000\u0000\u0000\u209b\u209c\u0003+\u0015\u0000"+ + "\u209c\u209d\u0003-\u0016\u0000\u209d\u209e\u0003+\u0015\u0000\u209e\u209f"+ + "\u0003-\u0016\u0000\u209f\u20a0\u0003\u000f\u0007\u0000\u20a0\u20a1\u0003"+ + "\u001f\u000f\u0000\u20a1\u061c\u0001\u0000\u0000\u0000\u20a2\u20a3\u0003"+ + "-\u0016\u0000\u20a3\u20a4\u0003\u000f\u0007\u0000\u20a4\u20a5\u00035\u001a"+ + "\u0000\u20a5\u20a6\u0003-\u0016\u0000\u20a6\u061e\u0001\u0000\u0000\u0000"+ + "\u20a7\u20a8\u0003-\u0016\u0000\u20a8\u20a9\u0003\u0017\u000b\u0000\u20a9"+ + "\u20aa\u0003\u001f\u000f\u0000\u20aa\u20ab\u0003\u000f\u0007\u0000\u20ab"+ + "\u20ac\u0003+\u0015\u0000\u20ac\u20ad\u0003-\u0016\u0000\u20ad\u20ae\u0003"+ + "\u0007\u0003\u0000\u20ae\u20af\u0003\u001f\u000f\u0000\u20af\u20b0\u0003"+ + "%\u0012\u0000\u20b0\u20b1\u0003-\u0016\u0000\u20b1\u20b2\u00039\u001c"+ + "\u0000\u20b2\u0620\u0001\u0000\u0000\u0000\u20b3\u20b4\u0003-\u0016\u0000"+ + "\u20b4\u20b5\u0003\u0017\u000b\u0000\u20b5\u20b6\u0003\u001f\u000f\u0000"+ + "\u20b6\u20b7\u0003\u000f\u0007\u0000\u20b7\u20b8\u0003-\u0016\u0000\u20b8"+ + "\u20b9\u00039\u001c\u0000\u20b9\u0622\u0001\u0000\u0000\u0000\u20ba\u20bb"+ + "\u0003-\u0016\u0000\u20bb\u20bc\u0003+\u0015\u0000\u20bc\u20bd\u0003\'"+ + "\u0013\u0000\u20bd\u20be\u0003/\u0017\u0000\u20be\u20bf\u0003\u000f\u0007"+ + "\u0000\u20bf\u20c0\u0003)\u0014\u0000\u20c0\u20c1\u00037\u001b\u0000\u20c1"+ + "\u0624\u0001\u0000\u0000\u0000\u20c2\u20c3\u0003-\u0016\u0000\u20c3\u20c4"+ + "\u0003+\u0015\u0000\u20c4\u20c5\u00031\u0018\u0000\u20c5\u20c6\u0003\u000f"+ + "\u0007\u0000\u20c6\u20c7\u0003\u000b\u0005\u0000\u20c7\u20c8\u0003-\u0016"+ + "\u0000\u20c8\u20c9\u0003#\u0011\u0000\u20c9\u20ca\u0003)\u0014\u0000\u20ca"+ + "\u0626\u0001\u0000\u0000\u0000\u20cb\u20cc\u0003-\u0016\u0000\u20cc\u20cd"+ + "\u00035\u001a\u0000\u20cd\u20ce\u0003\u0017\u000b\u0000\u20ce\u20cf\u0003"+ + "\r\u0006\u0000\u20cf\u20d0\u0005_\u0000\u0000\u20d0\u20d1\u0003+\u0015"+ + "\u0000\u20d1\u20d2\u0003!\u0010\u0000\u20d2\u20d3\u0003\u0007\u0003\u0000"+ + "\u20d3\u20d4\u0003%\u0012\u0000\u20d4\u20d5\u0003+\u0015\u0000\u20d5\u20d6"+ + "\u0003\u0015\n\u0000\u20d6\u20d7\u0003#\u0011\u0000\u20d7\u20d8\u0003"+ + "-\u0016\u0000\u20d8\u0628\u0001\u0000\u0000\u0000\u20d9\u20da\u0003/\u0017"+ + "\u0000\u20da\u20db\u0003/\u0017\u0000\u20db\u20dc\u0003\u0017\u000b\u0000"+ + "\u20dc\u20dd\u0003\r\u0006\u0000\u20dd\u062a\u0001\u0000\u0000\u0000\u20de"+ + "\u20df\u00031\u0018\u0000\u20df\u20e0\u0003\u0007\u0003\u0000\u20e0\u20e1"+ + "\u0003)\u0014\u0000\u20e1\u20e2\u0003\t\u0004\u0000\u20e2\u20e3\u0003"+ + "\u0017\u000b\u0000\u20e3\u20e4\u0003-\u0016\u0000\u20e4\u062c\u0001\u0000"+ + "\u0000\u0000\u20e5\u20e6\u00035\u001a\u0000\u20e6\u20e7\u0003\u001f\u000f"+ + "\u0000\u20e7\u20e8\u0003\u001d\u000e\u0000\u20e8\u062e\u0001\u0000\u0000"+ + "\u0000\u20e9\u20ea\u0005,\u0000\u0000\u20ea\u0630\u0001\u0000\u0000\u0000"+ + "\u20eb\u20ec\u0005:\u0000\u0000\u20ec\u0632\u0001\u0000\u0000\u0000\u20ed"+ + "\u20ee\u0005:\u0000\u0000\u20ee\u20ef\u0005:\u0000\u0000\u20ef\u0634\u0001"+ + "\u0000\u0000\u0000\u20f0\u20f1\u0005$\u0000\u0000\u20f1\u0636\u0001\u0000"+ + "\u0000\u0000\u20f2\u20f3\u0005$\u0000\u0000\u20f3\u20f4\u0005$\u0000\u0000"+ + "\u20f4\u0638\u0001\u0000\u0000\u0000\u20f5\u20f6\u0005*\u0000\u0000\u20f6"+ + "\u063a\u0001\u0000\u0000\u0000\u20f7\u20f8\u0005(\u0000\u0000\u20f8\u063c"+ + "\u0001\u0000\u0000\u0000\u20f9\u20fa\u0005)\u0000\u0000\u20fa\u063e\u0001"+ + "\u0000\u0000\u0000\u20fb\u20fc\u0005[\u0000\u0000\u20fc\u0640\u0001\u0000"+ + "\u0000\u0000\u20fd\u20fe\u0005]\u0000\u0000\u20fe\u0642\u0001\u0000\u0000"+ + "\u0000\u20ff\u2100\u0003\t\u0004\u0000\u2100\u2104\u0005\'\u0000\u0000"+ + "\u2101\u2103\u000201\u0000\u2102\u2101\u0001\u0000\u0000\u0000\u2103\u2106"+ + "\u0001\u0000\u0000\u0000\u2104\u2102\u0001\u0000\u0000\u0000\u2104\u2105"+ + "\u0001\u0000\u0000\u0000\u2105\u2107\u0001\u0000\u0000\u0000\u2106\u2104"+ + "\u0001\u0000\u0000\u0000\u2107\u2108\u0005\'\u0000\u0000\u2108\u0644\u0001"+ + "\u0000\u0000\u0000\u2109\u210a\u0003\u000f\u0007\u0000\u210a\u210b\u0003"+ + "A \u0000\u210b\u0646\u0001\u0000\u0000\u0000\u210c\u210e\u0005-\u0000"+ + "\u0000\u210d\u210c\u0001\u0000\u0000\u0000\u210d\u210e\u0001\u0000\u0000"+ + "\u0000\u210e\u2110\u0001\u0000\u0000\u0000\u210f\u2111\u0003=\u001e\u0000"+ + "\u2110\u210f\u0001\u0000\u0000\u0000\u2111\u2112\u0001\u0000\u0000\u0000"+ + "\u2112\u2110\u0001\u0000\u0000\u0000\u2112\u2113\u0001\u0000\u0000\u0000"+ + "\u2113\u2114\u0001\u0000\u0000\u0000\u2114\u2116\u0005.\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\u2126\u0001\u0000\u0000\u0000\u211a\u211e"+ + "\u0003\u000f\u0007\u0000\u211b\u211d\u0005-\u0000\u0000\u211c\u211b\u0001"+ + "\u0000\u0000\u0000\u211d\u2120\u0001\u0000\u0000\u0000\u211e\u211c\u0001"+ + "\u0000\u0000\u0000\u211e\u211f\u0001\u0000\u0000\u0000\u211f\u2122\u0001"+ + "\u0000\u0000\u0000\u2120\u211e\u0001\u0000\u0000\u0000\u2121\u2123\u0003"+ + "=\u001e\u0000\u2122\u2121\u0001\u0000\u0000\u0000\u2123\u2124\u0001\u0000"+ + "\u0000\u0000\u2124\u2122\u0001\u0000\u0000\u0000\u2124\u2125\u0001\u0000"+ + "\u0000\u0000\u2125\u2127\u0001\u0000\u0000\u0000\u2126\u211a\u0001\u0000"+ + "\u0000\u0000\u2126\u2127\u0001\u0000\u0000\u0000\u2127\u0648\u0001\u0000"+ + "\u0000\u0000\u2128\u212a\u0005-\u0000\u0000\u2129\u2128\u0001\u0000\u0000"+ + "\u0000\u2129\u212a\u0001\u0000\u0000\u0000\u212a\u212c\u0001\u0000\u0000"+ + "\u0000\u212b\u212d\u0003=\u001e\u0000\u212c\u212b\u0001\u0000\u0000\u0000"+ + "\u212d\u212e\u0001\u0000\u0000\u0000\u212e\u212c\u0001\u0000\u0000\u0000"+ + "\u212e\u212f\u0001\u0000\u0000\u0000\u212f\u2136\u0001\u0000\u0000\u0000"+ + "\u2130\u2132\u0003\u000f\u0007\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"+ + "\u2137\u0001\u0000\u0000\u0000\u2136\u2130\u0001\u0000\u0000\u0000\u2136"+ + "\u2137\u0001\u0000\u0000\u0000\u2137\u064a\u0001\u0000\u0000\u0000\u2138"+ + "\u2139\u0005x\u0000\u0000\u2139\u213a\u0003A \u0000\u213a\u064c\u0001"+ + "\u0000\u0000\u0000\u213b\u213c\u0005.\u0000\u0000\u213c\u064e\u0001\u0000"+ + "\u0000\u0000\u213d\u213e\u0003A \u0000\u213e\u0650\u0001\u0000\u0000\u0000"+ + "\u213f\u2140\u0003?\u001f\u0000\u2140\u0652\u0001\u0000\u0000\u0000\u2141"+ + "\u2145\u0007 \u0000\u0000\u2142\u2144\u0007!\u0000\u0000\u2143\u2142\u0001"+ + "\u0000\u0000\u0000\u2144\u2147\u0001\u0000\u0000\u0000\u2145\u2143\u0001"+ + "\u0000\u0000\u0000\u2145\u2146\u0001\u0000\u0000\u0000\u2146\u0654\u0001"+ + "\u0000\u0000\u0000\u2147\u2145\u0001\u0000\u0000\u0000\u2148\u214a\u0005"+ + "$\u0000\u0000\u2149\u214b\u0003=\u001e\u0000\u214a\u2149\u0001\u0000\u0000"+ + "\u0000\u214b\u214c\u0001\u0000\u0000\u0000\u214c\u214a\u0001\u0000\u0000"+ + "\u0000\u214c\u214d\u0001\u0000\u0000\u0000\u214d\u0656\u0001\u0000\u0000"+ + "\u0000\u214e\u2152\u0007\"\u0000\u0000\u214f\u2151\u0007#\u0000\u0000"+ + "\u2150\u214f\u0001\u0000\u0000\u0000\u2151\u2154\u0001\u0000\u0000\u0000"+ + "\u2152\u2150\u0001\u0000\u0000\u0000\u2152\u2153\u0001\u0000\u0000\u0000"+ + "\u2153\u0658\u0001\u0000\u0000\u0000\u2154\u2152\u0001\u0000\u0000\u0000"+ + "\u2155\u2156\u0005&\u0000\u0000\u2156\u065a\u0001\u0000\u0000\u0000\u2157"+ + "\u2158\u0005&\u0000\u0000\u2158\u2159\u0005&\u0000\u0000\u2159\u065c\u0001"+ + "\u0000\u0000\u0000\u215a\u215b\u0005&\u0000\u0000\u215b\u215c\u0005<\u0000"+ + "\u0000\u215c\u065e\u0001\u0000\u0000\u0000\u215d\u215e\u0005@\u0000\u0000"+ + "\u215e\u215f\u0005@\u0000\u0000\u215f\u0660\u0001\u0000\u0000\u0000\u2160"+ + "\u2161\u0005@\u0000\u0000\u2161\u2162\u0005>\u0000\u0000\u2162\u0662\u0001"+ + "\u0000\u0000\u0000\u2163\u2164\u0005@\u0000\u0000\u2164\u0664\u0001\u0000"+ + "\u0000\u0000\u2165\u2166\u0005!\u0000\u0000\u2166\u0666\u0001\u0000\u0000"+ + "\u0000\u2167\u2168\u0005!\u0000\u0000\u2168\u2169\u0005!\u0000\u0000\u2169"+ + "\u0668\u0001\u0000\u0000\u0000\u216a\u216b\u0005!\u0000\u0000\u216b\u216c"+ + "\u0005=\u0000\u0000\u216c\u066a\u0001\u0000\u0000\u0000\u216d\u216e\u0005"+ + "^\u0000\u0000\u216e\u066c\u0001\u0000\u0000\u0000\u216f\u2170\u0005=\u0000"+ + "\u0000\u2170\u066e\u0001\u0000\u0000\u0000\u2171\u2172\u0005=\u0000\u0000"+ + "\u2172\u2173\u0005>\u0000\u0000\u2173\u0670\u0001\u0000\u0000\u0000\u2174"+ + "\u2175\u0005>\u0000\u0000\u2175\u0672\u0001\u0000\u0000\u0000\u2176\u2177"+ + "\u0005>\u0000\u0000\u2177\u2178\u0005=\u0000\u0000\u2178\u0674\u0001\u0000"+ + "\u0000\u0000\u2179\u217a\u0005>\u0000\u0000\u217a\u217b\u0005>\u0000\u0000"+ + "\u217b\u0676\u0001\u0000\u0000\u0000\u217c\u217d\u0005#\u0000\u0000\u217d"+ + "\u0678\u0001\u0000\u0000\u0000\u217e\u217f\u0005#\u0000\u0000\u217f\u2180"+ + "\u0005=\u0000\u0000\u2180\u067a\u0001\u0000\u0000\u0000\u2181\u2182\u0005"+ + "#\u0000\u0000\u2182\u2183\u0005>\u0000\u0000\u2183\u067c\u0001\u0000\u0000"+ + "\u0000\u2184\u2185\u0005#\u0000\u0000\u2185\u2186\u0005>\u0000\u0000\u2186"+ + "\u2187\u0005>\u0000\u0000\u2187\u067e\u0001\u0000\u0000\u0000\u2188\u2189"+ + "\u0005#\u0000\u0000\u2189\u218a\u0005#\u0000\u0000\u218a\u0680\u0001\u0000"+ + "\u0000\u0000\u218b\u218c\u0005-\u0000\u0000\u218c\u218d\u0005>\u0000\u0000"+ + "\u218d\u0682\u0001\u0000\u0000\u0000\u218e\u218f\u0005-\u0000\u0000\u218f"+ + "\u2190\u0005>\u0000\u0000\u2190\u2191\u0005>\u0000\u0000\u2191\u0684\u0001"+ + "\u0000\u0000\u0000\u2192\u2193\u0005-\u0000\u0000\u2193\u2194\u0005|\u0000"+ + "\u0000\u2194\u2195\u0005-\u0000\u0000\u2195\u0686\u0001\u0000\u0000\u0000"+ + "\u2196\u2197\u0005<\u0000\u0000\u2197\u0688\u0001\u0000\u0000\u0000\u2198"+ + "\u2199\u0005<\u0000\u0000\u2199\u219a\u0005=\u0000\u0000\u219a\u068a\u0001"+ + "\u0000\u0000\u0000\u219b\u219c\u0005<\u0000\u0000\u219c\u219d\u0005@\u0000"+ + "\u0000\u219d\u068c\u0001\u0000\u0000\u0000\u219e\u219f\u0005<\u0000\u0000"+ + "\u219f\u21a0\u0005^\u0000\u0000\u21a0\u068e\u0001\u0000\u0000\u0000\u21a1"+ + "\u21a2\u0005<\u0000\u0000\u21a2\u21a3\u0005>\u0000\u0000\u21a3\u0690\u0001"+ + "\u0000\u0000\u0000\u21a4\u21a5\u0005<\u0000\u0000\u21a5\u21a6\u0005-\u0000"+ + "\u0000\u21a6\u21a7\u0005>\u0000\u0000\u21a7\u0692\u0001\u0000\u0000\u0000"+ + "\u21a8\u21a9\u0005<\u0000\u0000\u21a9\u21aa\u0005<\u0000\u0000\u21aa\u0694"+ + "\u0001\u0000\u0000\u0000\u21ab\u21ac\u0005<\u0000\u0000\u21ac\u21ad\u0005"+ + "<\u0000\u0000\u21ad\u21ae\u0005=\u0000\u0000\u21ae\u0696\u0001\u0000\u0000"+ + "\u0000\u21af\u21b0\u0005<\u0000\u0000\u21b0\u21b1\u0005?\u0000\u0000\u21b1"+ + "\u21b2\u0005>\u0000\u0000\u21b2\u0698\u0001\u0000\u0000\u0000\u21b3\u21b4"+ + "\u0005-\u0000\u0000\u21b4\u069a\u0001\u0000\u0000\u0000\u21b5\u21b6\u0005"+ + "%\u0000\u0000\u21b6\u069c\u0001\u0000\u0000\u0000\u21b7\u21b8\u0005|\u0000"+ + "\u0000\u21b8\u069e\u0001\u0000\u0000\u0000\u21b9\u21ba\u0005|\u0000\u0000"+ + "\u21ba\u21bb\u0005|\u0000\u0000\u21bb\u06a0\u0001\u0000\u0000\u0000\u21bc"+ + "\u21bd\u0005|\u0000\u0000\u21bd\u21be\u0005|\u0000\u0000\u21be\u21bf\u0005"+ + "/\u0000\u0000\u21bf\u06a2\u0001\u0000\u0000\u0000\u21c0\u21c1\u0005|\u0000"+ + "\u0000\u21c1\u21c2\u0005/\u0000\u0000\u21c2\u06a4\u0001\u0000\u0000\u0000"+ + "\u21c3\u21c4\u0005+\u0000\u0000\u21c4\u06a6\u0001\u0000\u0000\u0000\u21c5"+ + "\u21c6\u0005?\u0000\u0000\u21c6\u06a8\u0001\u0000\u0000\u0000\u21c7\u21c8"+ + "\u0005?\u0000\u0000\u21c8\u21c9\u0005&\u0000\u0000\u21c9\u06aa\u0001\u0000"+ + "\u0000\u0000\u21ca\u21cb\u0005?\u0000\u0000\u21cb\u21cc\u0005#\u0000\u0000"+ + "\u21cc\u06ac\u0001\u0000\u0000\u0000\u21cd\u21ce\u0005?\u0000\u0000\u21ce"+ + "\u21cf\u0005-\u0000\u0000\u21cf\u06ae\u0001\u0000\u0000\u0000\u21d0\u21d1"+ + "\u0005?\u0000\u0000\u21d1\u21d2\u0005|\u0000\u0000\u21d2\u06b0\u0001\u0000"+ + "\u0000\u0000\u21d3\u21d4\u0005/\u0000\u0000\u21d4\u06b2\u0001\u0000\u0000"+ + "\u0000\u21d5\u21d6\u0005~\u0000\u0000\u21d6\u06b4\u0001\u0000\u0000\u0000"+ + "\u21d7\u21d8\u0005~\u0000\u0000\u21d8\u21d9\u0005=\u0000\u0000\u21d9\u06b6"+ + "\u0001\u0000\u0000\u0000\u21da\u21db\u0005~\u0000\u0000\u21db\u21dc\u0005"+ + ">\u0000\u0000\u21dc\u21dd\u0005=\u0000\u0000\u21dd\u21de\u0005~\u0000"+ + "\u0000\u21de\u06b8\u0001\u0000\u0000\u0000\u21df\u21e0\u0005~\u0000\u0000"+ + "\u21e0\u21e1\u0005>\u0000\u0000\u21e1\u21e2\u0005~\u0000\u0000\u21e2\u06ba"+ + "\u0001\u0000\u0000\u0000\u21e3\u21e4\u0005~\u0000\u0000\u21e4\u21e5\u0005"+ + "<\u0000\u0000\u21e5\u21e6\u0005=\u0000\u0000\u21e6\u21e7\u0005~\u0000"+ + "\u0000\u21e7\u06bc\u0001\u0000\u0000\u0000\u21e8\u21e9\u0005~\u0000\u0000"+ + "\u21e9\u21ea\u0005<\u0000\u0000\u21ea\u21eb\u0005~\u0000\u0000\u21eb\u06be"+ + "\u0001\u0000\u0000\u0000\u21ec\u21ed\u0005~\u0000\u0000\u21ed\u21ee\u0005"+ + "*\u0000\u0000\u21ee\u06c0\u0001\u0000\u0000\u0000\u21ef\u21f0\u0005~\u0000"+ + "\u0000\u21f0\u21f1\u0005~\u0000\u0000\u21f1\u06c2\u0001\u0000\u0000\u0000"+ + "\u21f2\u21f3\u0005;\u0000\u0000\u21f3\u06c4\u0001\u0000\u0000\u0000\u21f4"+ + "\u21f5\u0005#\u0000\u0000\u21f5\u21f6\u0005{\u0000\u0000\u21f6\u21f7\u0001"+ + "\u0000\u0000\u0000\u21f7\u21f8\u0003\u06c7\u0363\u0000\u21f8\u21f9\u0005"+ + "}\u0000\u0000\u21f9\u06c6\u0001\u0000\u0000\u0000\u21fa\u21fc\t\u0000"+ + "\u0000\u0000\u21fb\u21fa\u0001\u0000\u0000\u0000\u21fc\u21ff\u0001\u0000"+ + "\u0000\u0000\u21fd\u21fe\u0001\u0000\u0000\u0000\u21fd\u21fb\u0001\u0000"+ + "\u0000\u0000\u21fe\u06c8\u0001\u0000\u0000\u0000\u21ff\u21fd\u0001\u0000"+ + "\u0000\u0000\u0019\u0000\u06cc\u06d6\u06e4\u0729\u072b\u0736\u0738\u0743"+ + "\u0745\u2104\u210d\u2112\u2118\u211e\u2124\u2126\u2129\u212e\u2134\u2136"+ + "\u2145\u214c\u2152\u21fd\u0002\u0006\u0000\u0000\u0000\u0001\u0000"; + public static final String _serializedATN = Utils.join( + new String[] { + _serializedATNSegment0, + _serializedATNSegment1, + _serializedATNSegment2, + _serializedATNSegment3 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ 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 new file mode 100644 index 000000000..eac3e65cf --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParser.java @@ -0,0 +1,50547 @@ +// 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.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"}) +public class PostgreSqlParser extends Parser { + 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_LEVEL_COUNT=585, TRAILING=586, TRANSACTION=587, TRANSACTION_ACTIVE=588, + TRANSACTIONS_COMMITTED=589, TRANSACTIONS_ROLLED_BACK=590, TRANSFORM=591, + TRANSFORMS=592, TRANSLATE=593, TRANSLATION=594, TREAT=595, TRIGGER=596, + TRIGGER_CATALOG=597, TRIGGER_NAME=598, TRIGGER_SCHEMA=599, TRIM=600, TRUE=601, + TRUNCATE=602, TRUSTED=603, TYPE=604, UESCAPE=605, UNBOUNDED=606, UNCOMMITTED=607, + UNDER=608, UNENCRYPTED=609, UNION=610, UNIQUE=611, UNKNOWN=612, UNLISTEN=613, + UNLOGGED=614, UNNAMED=615, UNNEST=616, UNTIL=617, UPDATE=618, UPPER=619, + USAGE=620, USER=621, USER_DEFINED_TYPE_CATALOG=622, USER_DEFINED_TYPE_CODE=623, + USER_DEFINED_TYPE_NAME=624, USER_DEFINED_TYPE_SCHEMA=625, USING=626, VACUUM=627, + VALID=628, VALIDATE=629, VALIDATOR=630, VALUE=631, VALUES=632, VAR_POP=633, + VAR_SAMP=634, VARCHAR=635, VARIABLE=636, VARIADIC=637, VARYING=638, VERBOSE=639, + VIEW=640, VOLATILE=641, WHEN=642, WHENEVER=643, WHERE=644, WIDTH_BUCKET=645, + WINDOW=646, WITH=647, WITHIN=648, WITHOUT=649, WORK=650, WRITE=651, YAML=652, + YEAR=653, YES=654, ZONE=655, SUPERUSER=656, NOSUPERUSER=657, CREATEROLE=658, + NOCREATEROLE=659, INHERIT=660, NOINHERIT=661, LOGIN=662, NOLOGIN=663, + REPLICATION=664, NOREPLICATION=665, BYPASSRLS=666, NOBYPASSRLS=667, SFUNC=668, + STYPE=669, SSPACE=670, FINALFUNC=671, FINALFUNC_EXTRA=672, COMBINEFUNC=673, + SERIALFUNC=674, DESERIALFUNC=675, INITCOND=676, MSFUNC=677, MINVFUNC=678, + MSTYPE=679, MSSPACE=680, MFINALFUNC=681, MFINALFUNC_EXTRA=682, MINITCOND=683, + SORTOP=684, PARALLEL=685, HYPOTHETICAL=686, SAFE=687, RESTRICTED=688, + UNSAFE=689, BASETYPE=690, IF=691, LOCALE=692, LC_COLLATE=693, LC_CTYPE=694, + PROVIDER=695, VERSION=696, ALLOW_CONNECTIONS=697, IS_TEMPLATE=698, EVENT=699, + WRAPPER=700, SERVER=701, BTREE=702, HASH_=703, GIST=704, SPGIST=705, GIN=706, + BRIN=707, CONCURRENTLY=708, INLINE=709, MATERIALIZED=710, LEFTARG=711, + RIGHTARG=712, COMMUTATOR=713, NEGATOR=714, HASHES=715, MERGES=716, FAMILY=717, + POLICY=718, OWNED=719, ABSTIME=720, BIGSERIAL=721, BIT_VARYING=722, BOOL=723, + BOX=724, BYTEA=725, CHARACTER_VARYING=726, CIDR=727, CIRCLE=728, FLOAT4=729, + FLOAT8=730, INET=731, INT2=732, INT4=733, INT8=734, JSON=735, JSONB=736, + LINE=737, LSEG=738, MACADDR=739, MACADDR8=740, MONEY=741, PG_LSN=742, + POINT=743, POLYGON=744, RELTIME=745, SERIAL=746, SERIAL2=747, SERIAL4=748, + SERIAL8=749, SMALLSERIAL=750, STSTEM=751, TEXT=752, TIMESTAMPTZ=753, TIMETZ=754, + TSQUERY=755, TSVECTOR=756, TXID_SNAPSHOT=757, UUID=758, VARBIT=759, XML=760, + COMMA=761, COLON=762, COLON_COLON=763, DOLLAR=764, DOLLAR_DOLLAR=765, + STAR=766, OPEN_PAREN=767, CLOSE_PAREN=768, OPEN_BRACKET=769, CLOSE_BRACKET=770, + BIT_STRING=771, REGEX_STRING=772, NUMERIC_LITERAL=773, INTEGER_LITERAL=774, + HEX_INTEGER_LITERAL=775, DOT=776, SINGLEQ_STRING_LITERAL=777, DOUBLEQ_STRING_LITERAL=778, + IDENTIFIER=779, DOLLAR_DEC=780, IDENTIFIER_UNICODE=781, AMP=782, AMP_AMP=783, + AMP_LT=784, AT_AT=785, AT_GT=786, AT_SIGN=787, BANG=788, BANG_BANG=789, + BANG_EQUAL=790, CARET=791, EQUAL=792, EQUAL_GT=793, GT=794, GTE=795, GT_GT=796, + HASH=797, HASH_EQ=798, HASH_GT=799, HASH_GT_GT=800, HASH_HASH=801, HYPHEN_GT=802, + HYPHEN_GT_GT=803, HYPHEN_PIPE_HYPHEN=804, LT=805, LTE=806, LT_AT=807, + LT_CARET=808, LT_GT=809, LT_HYPHEN_GT=810, LT_LT=811, LT_LT_EQ=812, LT_QMARK_GT=813, + MINUS=814, PERCENT=815, PIPE=816, PIPE_PIPE=817, PIPE_PIPE_SLASH=818, + PIPE_SLASH=819, PLUS=820, QMARK=821, QMARK_AMP=822, QMARK_HASH=823, QMARK_HYPHEN=824, + QMARK_PIPE=825, SLASH=826, TIL=827, TIL_EQ=828, TIL_GTE_TIL=829, TIL_GT_TIL=830, + TIL_LTE_TIL=831, TIL_LT_TIL=832, TIL_STAR=833, TIL_TIL=834, SEMI=835, + SPEL=836; + 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 = 204, + RULE_window_clause = 205, RULE_combine_clause = 206, RULE_order_by_clause = 207, + RULE_order_by_item = 208, RULE_limit_clause = 209, RULE_offset_clause = 210, + RULE_fetch_clause = 211, RULE_for_clause = 212, RULE_updater_clause = 213, + RULE_updater_expr = 214, RULE_returning_clause = 215, RULE_expr = 216, + RULE_parameter = 217, RULE_bool_expr = 218, RULE_case_expr = 219, RULE_expr_list = 220, + RULE_expr_list_list = 221, RULE_func_sig_arg = 222, RULE_func_sig_arg_list = 223, + RULE_func_sig = 224, RULE_func_sig_list = 225, RULE_type_name = 226, RULE_timezone = 227, + RULE_oper = 228, RULE_aggregate = 229, RULE_name_ = 230, RULE_name_list = 231, + RULE_identifier_list = 232, RULE_option_expr = 233, RULE_option_list = 234, + RULE_table_name_ = 235, RULE_data_type = 236, RULE_data_type_list = 237, + RULE_index_method = 238, RULE_func_name = 239, RULE_func_call = 240, RULE_array_cons_expr = 241, + RULE_from_item = 242, RULE_with_column_alias = 243, RULE_join_type = 244, + RULE_join_clause = 245, RULE_predicate = 246, RULE_aggregate_signature = 247, + RULE_column_constraint = 248, RULE_column_constraints = 249, RULE_index_parameters = 250, + RULE_exclude_element = 251, RULE_table_constraint = 252, RULE_role_name = 253, + RULE_role_name_list = 254, RULE_param_value = 255, RULE_non_reserved_keyword = 256, + RULE_identifier = 257, RULE_todo_fill_in = 258, RULE_todo_implement = 259, + RULE_correlation_name = 260, RULE_column_name = 261, RULE_alias = 262, + RULE_column_alias = 263, RULE_column_definition = 264, RULE_window_name = 265; + 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", "window_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", + "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", "non_reserved_keyword", + "identifier", "todo_fill_in", "todo_implement", "correlation_name", "column_name", + "alias", "column_alias", "column_definition", "window_name" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, null, null, null, + null, null, null, 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_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" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "PostgreSqlParser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public PostgreSqlParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @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 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); + } + @Override public int getRuleIndex() { return RULE_root; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterRoot(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitRoot(this); + } + } + + 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(532); + stmt(); + setState(541); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(535); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(533); + match(SEMI); + setState(534); + stmt(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(537); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,0,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(539); + match(SEMI); + } + } + + setState(543); + match(EOF); + } + } + 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 Alter_stmtContext alter_stmt() { + return getRuleContext(Alter_stmtContext.class,0); + } + public Analyze_stmtContext analyze_stmt() { + return getRuleContext(Analyze_stmtContext.class,0); + } + public Create_stmtContext create_stmt() { + return getRuleContext(Create_stmtContext.class,0); + } + public Close_stmtContext close_stmt() { + return getRuleContext(Close_stmtContext.class,0); + } + public Cluster_stmtContext cluster_stmt() { + return getRuleContext(Cluster_stmtContext.class,0); + } + public Comment_stmtContext comment_stmt() { + return getRuleContext(Comment_stmtContext.class,0); + } + public Commit_stmtContext commit_stmt() { + return getRuleContext(Commit_stmtContext.class,0); + } + public Commit_prepared_stmtContext commit_prepared_stmt() { + return getRuleContext(Commit_prepared_stmtContext.class,0); + } + public Copy_stmtContext copy_stmt() { + return getRuleContext(Copy_stmtContext.class,0); + } + public Deallocate_stmtContext deallocate_stmt() { + return getRuleContext(Deallocate_stmtContext.class,0); + } + public Declare_stmtContext declare_stmt() { + return getRuleContext(Declare_stmtContext.class,0); + } + public Delete_stmtContext delete_stmt() { + return getRuleContext(Delete_stmtContext.class,0); + } + public Discard_stmtContext discard_stmt() { + return getRuleContext(Discard_stmtContext.class,0); + } + public Drop_stmtContext drop_stmt() { + return getRuleContext(Drop_stmtContext.class,0); + } + public Execute_stmtContext execute_stmt() { + return getRuleContext(Execute_stmtContext.class,0); + } + public Explain_stmtContext explain_stmt() { + return getRuleContext(Explain_stmtContext.class,0); + } + public Fetch_stmtContext fetch_stmt() { + return getRuleContext(Fetch_stmtContext.class,0); + } + public Grant_stmtContext grant_stmt() { + return getRuleContext(Grant_stmtContext.class,0); + } + public Import_foreign_schema_stmtContext import_foreign_schema_stmt() { + return getRuleContext(Import_foreign_schema_stmtContext.class,0); + } + public Insert_stmtContext insert_stmt() { + return getRuleContext(Insert_stmtContext.class,0); + } + public Listen_stmtContext listen_stmt() { + return getRuleContext(Listen_stmtContext.class,0); + } + public Load_stmtContext load_stmt() { + return getRuleContext(Load_stmtContext.class,0); + } + public Lock_stmtContext lock_stmt() { + return getRuleContext(Lock_stmtContext.class,0); + } + public Move_stmtContext move_stmt() { + return getRuleContext(Move_stmtContext.class,0); + } + public Notify_stmtContext notify_stmt() { + return getRuleContext(Notify_stmtContext.class,0); + } + public Prepare_stmtContext prepare_stmt() { + return getRuleContext(Prepare_stmtContext.class,0); + } + public Prepare_transaction_stmtContext prepare_transaction_stmt() { + return getRuleContext(Prepare_transaction_stmtContext.class,0); + } + public Reassign_owned_stmtContext reassign_owned_stmt() { + return getRuleContext(Reassign_owned_stmtContext.class,0); + } + public Refresh_materialized_view_stmtContext refresh_materialized_view_stmt() { + return getRuleContext(Refresh_materialized_view_stmtContext.class,0); + } + public Reindex_stmtContext reindex_stmt() { + return getRuleContext(Reindex_stmtContext.class,0); + } + public Release_savepoint_stmtContext release_savepoint_stmt() { + return getRuleContext(Release_savepoint_stmtContext.class,0); + } + public Reset_stmtContext reset_stmt() { + return getRuleContext(Reset_stmtContext.class,0); + } + public Revoke_stmtContext revoke_stmt() { + return getRuleContext(Revoke_stmtContext.class,0); + } + public Rollback_stmtContext rollback_stmt() { + return getRuleContext(Rollback_stmtContext.class,0); + } + public Rollback_prepared_stmtContext rollback_prepared_stmt() { + return getRuleContext(Rollback_prepared_stmtContext.class,0); + } + public Rollback_to_savepoint_stmtContext rollback_to_savepoint_stmt() { + return getRuleContext(Rollback_to_savepoint_stmtContext.class,0); + } + public Savepoint_stmtContext savepoint_stmt() { + return getRuleContext(Savepoint_stmtContext.class,0); + } + public Security_label_stmtContext security_label_stmt() { + return getRuleContext(Security_label_stmtContext.class,0); + } + public Select_stmtContext select_stmt() { + return getRuleContext(Select_stmtContext.class,0); + } + public Select_into_stmtContext select_into_stmt() { + return getRuleContext(Select_into_stmtContext.class,0); + } + public Set_stmtContext set_stmt() { + return getRuleContext(Set_stmtContext.class,0); + } + public Set_constraints_stmtContext set_constraints_stmt() { + return getRuleContext(Set_constraints_stmtContext.class,0); + } + public Set_role_stmtContext set_role_stmt() { + return getRuleContext(Set_role_stmtContext.class,0); + } + public Set_session_authorization_stmtContext set_session_authorization_stmt() { + return getRuleContext(Set_session_authorization_stmtContext.class,0); + } + public Set_transaction_stmtContext set_transaction_stmt() { + return getRuleContext(Set_transaction_stmtContext.class,0); + } + public Show_stmtContext show_stmt() { + return getRuleContext(Show_stmtContext.class,0); + } + public Truncate_stmtContext truncate_stmt() { + return getRuleContext(Truncate_stmtContext.class,0); + } + public Unlisten_stmtContext unlisten_stmt() { + return getRuleContext(Unlisten_stmtContext.class,0); + } + public Update_stmtContext update_stmt() { + return getRuleContext(Update_stmtContext.class,0); + } + public Vacuum_stmtContext vacuum_stmt() { + return getRuleContext(Vacuum_stmtContext.class,0); + } + public Values_stmtContext values_stmt() { + return getRuleContext(Values_stmtContext.class,0); + } + public StmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterStmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitStmt(this); + } + } + + public final StmtContext stmt() throws RecognitionException { + StmtContext _localctx = new StmtContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(597); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) { + case 1: + { + setState(545); + abort_stmt(); + } + break; + case 2: + { + setState(546); + alter_stmt(); + } + break; + case 3: + { + setState(547); + analyze_stmt(); + } + break; + case 4: + { + setState(548); + create_stmt(); + } + break; + case 5: + { + setState(549); + close_stmt(); + } + break; + case 6: + { + setState(550); + cluster_stmt(); + } + break; + case 7: + { + setState(551); + comment_stmt(); + } + break; + case 8: + { + setState(552); + commit_stmt(); + } + break; + case 9: + { + setState(553); + commit_prepared_stmt(); + } + break; + case 10: + { + setState(554); + copy_stmt(); + } + break; + case 11: + { + setState(555); + deallocate_stmt(); + } + break; + case 12: + { + setState(556); + declare_stmt(); + } + break; + case 13: + { + setState(557); + delete_stmt(); + } + break; + case 14: + { + setState(558); + discard_stmt(); + } + break; + case 15: + { + setState(559); + drop_stmt(); + } + break; + case 16: + { + setState(560); + execute_stmt(); + } + break; + case 17: + { + setState(561); + explain_stmt(); + } + break; + case 18: + { + setState(562); + fetch_stmt(); + } + break; + case 19: + { + setState(563); + grant_stmt(); + } + break; + case 20: + { + setState(564); + import_foreign_schema_stmt(); + } + break; + case 21: + { + setState(565); + insert_stmt(); + } + break; + case 22: + { + setState(566); + listen_stmt(); + } + break; + case 23: + { + setState(567); + load_stmt(); + } + break; + case 24: + { + setState(568); + lock_stmt(); + } + break; + case 25: + { + setState(569); + move_stmt(); + } + break; + case 26: + { + setState(570); + notify_stmt(); + } + break; + case 27: + { + setState(571); + prepare_stmt(); + } + break; + case 28: + { + setState(572); + prepare_transaction_stmt(); + } + break; + case 29: + { + setState(573); + reassign_owned_stmt(); + } + break; + case 30: + { + setState(574); + refresh_materialized_view_stmt(); + } + break; + case 31: + { + setState(575); + reindex_stmt(); + } + break; + case 32: + { + setState(576); + release_savepoint_stmt(); + } + break; + case 33: + { + setState(577); + reset_stmt(); + } + break; + case 34: + { + setState(578); + revoke_stmt(); + } + break; + case 35: + { + setState(579); + rollback_stmt(); + } + break; + case 36: + { + setState(580); + rollback_prepared_stmt(); + } + break; + case 37: + { + setState(581); + rollback_to_savepoint_stmt(); + } + break; + case 38: + { + setState(582); + savepoint_stmt(); + } + break; + case 39: + { + setState(583); + security_label_stmt(); + } + break; + case 40: + { + setState(584); + select_stmt(); + } + break; + case 41: + { + setState(585); + select_into_stmt(); + } + break; + case 42: + { + setState(586); + set_stmt(); + } + break; + case 43: + { + setState(587); + set_constraints_stmt(); + } + break; + case 44: + { + setState(588); + set_role_stmt(); + } + break; + case 45: + { + setState(589); + set_session_authorization_stmt(); + } + break; + case 46: + { + setState(590); + set_transaction_stmt(); + } + break; + case 47: + { + setState(591); + show_stmt(); + } + break; + case 48: + { + setState(592); + truncate_stmt(); + } + break; + case 49: + { + setState(593); + unlisten_stmt(); + } + break; + case 50: + { + setState(594); + update_stmt(); + } + break; + case 51: + { + setState(595); + vacuum_stmt(); + } + break; + case 52: + { + setState(596); + 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(599); + 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(641); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(601); + alter_aggregate_stmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(602); + alter_collation_stmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(603); + alter_conversion_stmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(604); + alter_database_stmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(605); + alter_default_privileges_stmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(606); + alter_domain_stmt(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(607); + alter_event_trigger_stmt(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(608); + alter_extension_stmt(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(609); + alter_foreign_data_wrapper_stmt(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(610); + alter_foreign_table_stmt(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(611); + alter_function_stmt(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(612); + alter_group_stmt(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(613); + alter_index_stmt(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(614); + alter_language_stmt(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(615); + alter_large_object_stmt(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(616); + alter_materialize_view_stmt(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(617); + alter_operator_stmt(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(618); + alter_operator_class_stmt(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(619); + alter_operator_family_stmt(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(620); + alter_policy_stmt(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(621); + alter_publication_stmt(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(622); + alter_role_stmt(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(623); + alter_rule_stmt(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(624); + alter_schema_stmt(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(625); + alter_sequence_stmt(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(626); + alter_server_stmt(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(627); + alter_statistics_stmt(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(628); + alter_subscription_stmt(); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(629); + alter_system_stmt(); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(630); + alter_table_stmt(); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(631); + alter_tablespace_stmt(); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(632); + alter_text_search_config_stmt(); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(633); + alter_text_search_dict_stmt(); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(634); + alter_text_search_parser_stmt(); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(635); + alter_text_search_template_stmt(); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(636); + alter_trigger_stmt(); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(637); + alter_type_stmt(); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(638); + alter_user_stmt(); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(639); + alter_user_mapping_stmt(); + } + break; + case 40: + enterOuterAlt(_localctx, 40); + { + setState(640); + 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(673); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(643); + match(ALTER); + setState(644); + match(AGGREGATE); + setState(645); + ((Alter_aggregate_stmtContext)_localctx).name = identifier(0); + setState(646); + match(OPEN_PAREN); + setState(647); + aggregate_signature(); + setState(648); + match(CLOSE_PAREN); + setState(649); + match(RENAME); + setState(650); + match(TO); + setState(651); + ((Alter_aggregate_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(653); + match(ALTER); + setState(654); + match(AGGREGATE); + setState(655); + ((Alter_aggregate_stmtContext)_localctx).name = identifier(0); + setState(656); + match(OPEN_PAREN); + setState(657); + aggregate_signature(); + setState(658); + match(CLOSE_PAREN); + setState(659); + match(OWNER); + setState(660); + match(TO); + setState(661); + ((Alter_aggregate_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(663); + match(ALTER); + setState(664); + match(AGGREGATE); + setState(665); + ((Alter_aggregate_stmtContext)_localctx).name = identifier(0); + setState(666); + match(OPEN_PAREN); + setState(667); + aggregate_signature(); + setState(668); + match(CLOSE_PAREN); + setState(669); + match(SET); + setState(670); + match(SCHEMA); + setState(671); + ((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(702); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(675); + match(ALTER); + setState(676); + match(COLLATION); + setState(677); + ((Alter_collation_stmtContext)_localctx).name = name_(); + setState(678); + match(REFRESH); + setState(679); + match(VERSION); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(681); + match(ALTER); + setState(682); + match(COLLATION); + setState(683); + ((Alter_collation_stmtContext)_localctx).name = name_(); + setState(684); + match(RENAME); + setState(685); + match(TO); + setState(686); + ((Alter_collation_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(688); + match(ALTER); + setState(689); + match(COLLATION); + setState(690); + ((Alter_collation_stmtContext)_localctx).name = name_(); + setState(691); + match(OWNER); + setState(692); + match(TO); + setState(693); + ((Alter_collation_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(695); + match(ALTER); + setState(696); + match(COLLATION); + setState(697); + ((Alter_collation_stmtContext)_localctx).name = name_(); + setState(698); + match(SET); + setState(699); + match(SCHEMA); + setState(700); + ((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(725); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(704); + match(ALTER); + setState(705); + match(CONVERSION); + setState(706); + ((Alter_conversion_stmtContext)_localctx).name = identifier(0); + setState(707); + match(RENAME); + setState(708); + match(TO); + setState(709); + ((Alter_conversion_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(711); + match(ALTER); + setState(712); + match(CONVERSION); + setState(713); + ((Alter_conversion_stmtContext)_localctx).name = identifier(0); + setState(714); + match(OWNER); + setState(715); + match(TO); + setState(716); + ((Alter_conversion_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(718); + match(ALTER); + setState(719); + match(CONVERSION); + setState(720); + ((Alter_conversion_stmtContext)_localctx).name = identifier(0); + setState(721); + match(SET); + setState(722); + match(SCHEMA); + setState(723); + ((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(727); + 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(729); + 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(807); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(731); + match(ALTER); + setState(732); + match(DOMAIN); + setState(733); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(739); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + { + setState(734); + match(SET); + setState(735); + match(DEFAULT); + setState(736); + expr(0); + } + break; + case DROP: + { + setState(737); + match(DROP); + setState(738); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(741); + match(ALTER); + setState(742); + match(DOMAIN); + setState(743); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(744); + _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(745); + match(NOT); + setState(746); + match(NULL); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(748); + match(ALTER); + setState(749); + match(DOMAIN); + setState(750); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(751); + match(ADD); + setState(752); + domain_constraint(); + setState(755); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(753); + match(NOT); + setState(754); + match(VALID); + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(757); + match(ALTER); + setState(758); + match(DOMAIN); + setState(759); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(760); + match(DROP); + setState(761); + match(CONSTRAINT); + setState(764); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(762); + match(IF); + setState(763); + match(EXISTS); + } + } + + setState(766); + ((Alter_domain_stmtContext)_localctx).constraint_name = identifier(0); + setState(768); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(767); + _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(770); + match(ALTER); + setState(771); + match(DOMAIN); + setState(772); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(773); + match(RENAME); + setState(774); + match(CONSTRAINT); + setState(775); + ((Alter_domain_stmtContext)_localctx).constraint_name = identifier(0); + setState(776); + match(TO); + setState(777); + ((Alter_domain_stmtContext)_localctx).new_constraint_name = identifier(0); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(779); + match(ALTER); + setState(780); + match(DOMAIN); + setState(781); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(782); + match(VALIDATE); + setState(783); + match(CONSTRAINT); + setState(784); + ((Alter_domain_stmtContext)_localctx).constraint_name = identifier(0); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(786); + match(ALTER); + setState(787); + match(DOMAIN); + setState(788); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(789); + match(OWNER); + setState(790); + match(TO); + setState(791); + ((Alter_domain_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(793); + match(ALTER); + setState(794); + match(DOMAIN); + setState(795); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(796); + match(RENAME); + setState(797); + match(TO); + setState(798); + ((Alter_domain_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(800); + match(ALTER); + setState(801); + match(DOMAIN); + setState(802); + ((Alter_domain_stmtContext)_localctx).name = identifier(0); + setState(803); + match(SET); + setState(804); + match(SCHEMA); + setState(805); + ((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(842); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(809); + match(ALTER); + setState(810); + match(EVENT); + setState(811); + match(TRIGGER); + setState(812); + ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); + setState(813); + match(DISABLE); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(815); + match(ALTER); + setState(816); + match(EVENT); + setState(817); + match(TRIGGER); + setState(818); + ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); + setState(819); + match(ENABLE); + setState(821); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALWAYS || _la==REPLICA) { + { + setState(820); + _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(823); + match(ALTER); + setState(824); + match(EVENT); + setState(825); + match(TRIGGER); + setState(826); + ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); + setState(827); + match(OWNER); + setState(828); + match(TO); + setState(832); + _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_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 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(829); + ((Alter_event_trigger_stmtContext)_localctx).new_owner = identifier(0); + } + break; + case CURRENT_USER: + { + setState(830); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(831); + match(SESSION_USER); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(834); + match(ALTER); + setState(835); + match(EVENT); + setState(836); + match(TRIGGER); + setState(837); + ((Alter_event_trigger_stmtContext)_localctx).name = identifier(0); + setState(838); + match(RENAME); + setState(839); + match(TO); + setState(840); + ((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(859); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(844); + match(ALTER); + setState(845); + match(EXTENSION); + setState(846); + ((Alter_extension_stmtContext)_localctx).name = identifier(0); + setState(847); + match(UPDATE); + setState(850); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TO) { + { + setState(848); + match(TO); + setState(849); + ((Alter_extension_stmtContext)_localctx).new_version = identifier(0); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(852); + match(ALTER); + setState(853); + match(EXTENSION); + setState(854); + ((Alter_extension_stmtContext)_localctx).name = identifier(0); + setState(855); + match(SET); + setState(856); + match(SCHEMA); + setState(857); + ((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(861); + 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(1035); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(863); + match(ADD); + setState(865); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(864); + match(COLUMN); + } + } + + setState(867); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(868); + ((Alter_foreign_table_actionContext)_localctx).data_type_ = data_type(); + setState(871); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLLATE) { + { + setState(869); + match(COLLATE); + setState(870); + ((Alter_foreign_table_actionContext)_localctx).collation = identifier(0); + } + } + + setState(874); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(873); + ((Alter_foreign_table_actionContext)_localctx).column_constraints_ = column_constraints(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(876); + match(DROP); + setState(878); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(877); + match(COLUMN); + } + } + + setState(882); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(880); + match(IF); + setState(881); + match(EXISTS); + } + } + + setState(884); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(886); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(885); + _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(888); + match(ALTER); + setState(890); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(889); + match(COLUMN); + } + } + + setState(892); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(895); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SET) { + { + setState(893); + match(SET); + setState(894); + match(DATA); + } + } + + setState(897); + match(TYPE); + setState(898); + ((Alter_foreign_table_actionContext)_localctx).data_type_ = data_type(); + setState(901); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLLATE) { + { + setState(899); + match(COLLATE); + setState(900); + ((Alter_foreign_table_actionContext)_localctx).collation = identifier(0); + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(903); + match(ALTER); + setState(905); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(904); + match(COLUMN); + } + } + + setState(907); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(908); + match(SET); + setState(909); + match(DEFAULT); + setState(910); + expr(0); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(912); + match(ALTER); + setState(914); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(913); + match(COLUMN); + } + } + + setState(916); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(917); + match(DROP); + setState(918); + match(DEFAULT); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(920); + match(ALTER); + setState(922); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(921); + match(COLUMN); + } + } + + setState(924); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(925); + _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(926); + match(NOT); + setState(927); + match(NULL); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(929); + match(ALTER); + setState(931); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(930); + match(COLUMN); + } + } + + setState(933); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(934); + match(SET); + setState(935); + match(STATISTICS); + setState(936); + match(INTEGER); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(938); + match(ALTER); + setState(940); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(939); + match(COLUMN); + } + } + + setState(942); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(943); + match(SET); + setState(944); + match(OPEN_PAREN); + setState(945); + ((Alter_foreign_table_actionContext)_localctx).attribute_values = option_list(); + setState(946); + match(CLOSE_PAREN); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(948); + match(ALTER); + setState(950); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(949); + match(COLUMN); + } + } + + setState(952); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(953); + match(RESET); + setState(954); + match(OPEN_PAREN); + setState(955); + ((Alter_foreign_table_actionContext)_localctx).attributes = identifier_list(); + setState(956); + match(CLOSE_PAREN); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(958); + match(ALTER); + setState(960); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(959); + match(COLUMN); + } + } + + setState(962); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(963); + match(SET); + setState(964); + match(STORAGE); + setState(965); + _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(967); + match(ALTER); + setState(969); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(968); + match(COLUMN); + } + } + + setState(971); + ((Alter_foreign_table_actionContext)_localctx).column_name_ = column_name(); + setState(972); + match(OPTIONS); + { + setState(974); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ADD || _la==DROP || _la==SET) { + { + setState(973); + _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(976); + match(ADD); + setState(977); + table_constraint(); + setState(980); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(978); + match(NOT); + setState(979); + match(VALID); + } + } + + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(982); + match(VALIDATE); + setState(983); + match(CONSTRAINT); + setState(984); + ((Alter_foreign_table_actionContext)_localctx).constraint_name = todo_fill_in(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(985); + match(DROP); + setState(986); + match(CONSTRAINT); + setState(989); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { + case 1: + { + setState(987); + match(IF); + setState(988); + match(EXISTS); + } + break; + } + setState(991); + ((Alter_foreign_table_actionContext)_localctx).constraint_name = todo_fill_in(); + setState(993); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(992); + _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(995); + match(DISABLE); + setState(996); + match(TRIGGER); + setState(1000); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { + case 1: + { + setState(997); + ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); + } + break; + case 2: + { + setState(998); + match(ALL); + } + break; + case 3: + { + setState(999); + match(USER); + } + break; + } + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(1002); + match(ENABLE); + setState(1003); + match(TRIGGER); + setState(1007); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { + case 1: + { + setState(1004); + ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); + } + break; + case 2: + { + setState(1005); + match(ALL); + } + break; + case 3: + { + setState(1006); + match(USER); + } + break; + } + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(1009); + match(ENABLE); + setState(1010); + match(REPLICA); + setState(1011); + match(TRIGGER); + setState(1012); + ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(1013); + match(ENABLE); + setState(1014); + match(ALWAYS); + setState(1015); + match(TRIGGER); + setState(1016); + ((Alter_foreign_table_actionContext)_localctx).trigger_name = todo_fill_in(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(1017); + match(SET); + setState(1018); + match(WITH); + setState(1019); + match(OIDS); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(1020); + match(SET); + setState(1021); + match(WITHOUT); + setState(1022); + match(OIDS); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(1023); + match(INHERIT); + setState(1024); + ((Alter_foreign_table_actionContext)_localctx).parent_table = identifier(0); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(1025); + match(NO); + setState(1026); + match(INHERIT); + setState(1027); + ((Alter_foreign_table_actionContext)_localctx).parent_table = identifier(0); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(1028); + match(OWNER); + setState(1029); + match(TO); + setState(1030); + ((Alter_foreign_table_actionContext)_localctx).new_owner = role_name(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(1031); + match(OPTIONS); + { + setState(1033); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ADD || _la==DROP || _la==SET) { + { + setState(1032); + _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(1037); + alter_foreign_table_action(); + setState(1042); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1038); + match(COMMA); + setState(1039); + alter_foreign_table_action(); + } + } + setState(1044); + _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(1107); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1045); + match(ALTER); + setState(1046); + match(FOREIGN); + setState(1047); + match(TABLE); + setState(1050); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1048); + match(IF); + setState(1049); + match(EXISTS); + } + } + + setState(1053); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(1052); + match(ONLY); + } + } + + setState(1055); + ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); + setState(1057); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STAR) { + { + setState(1056); + match(STAR); + } + } + + setState(1059); + ((Alter_foreign_table_stmtContext)_localctx).actions = alter_foreign_table_action_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1061); + match(ALTER); + setState(1062); + match(FOREIGN); + setState(1063); + match(TABLE); + setState(1066); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1064); + match(IF); + setState(1065); + match(EXISTS); + } + } + + setState(1069); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(1068); + match(ONLY); + } + } + + setState(1071); + ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); + setState(1073); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STAR) { + { + setState(1072); + match(STAR); + } + } + + setState(1075); + match(RENAME); + setState(1077); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLUMN) { + { + setState(1076); + match(COLUMN); + } + } + + setState(1079); + ((Alter_foreign_table_stmtContext)_localctx).column_name_ = column_name(); + setState(1080); + match(TO); + setState(1081); + ((Alter_foreign_table_stmtContext)_localctx).new_column_name = identifier(0); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1083); + match(ALTER); + setState(1084); + match(FOREIGN); + setState(1085); + match(TABLE); + setState(1088); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1086); + match(IF); + setState(1087); + match(EXISTS); + } + } + + setState(1090); + ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); + setState(1091); + match(RENAME); + setState(1092); + match(TO); + setState(1093); + ((Alter_foreign_table_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1095); + match(ALTER); + setState(1096); + match(FOREIGN); + setState(1097); + match(TABLE); + setState(1100); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1098); + match(IF); + setState(1099); + match(EXISTS); + } + } + + setState(1102); + ((Alter_foreign_table_stmtContext)_localctx).name = identifier(0); + setState(1103); + match(SET); + setState(1104); + match(SCHEMA); + setState(1105); + ((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(1109); + 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(1132); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1111); + match(ALTER); + setState(1112); + match(GROUP); + setState(1113); + ((Alter_group_stmtContext)_localctx).role = role_name(); + setState(1114); + match(ADD); + setState(1115); + match(USER); + setState(1116); + ((Alter_group_stmtContext)_localctx).users = identifier_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1118); + match(ALTER); + setState(1119); + match(GROUP); + setState(1120); + ((Alter_group_stmtContext)_localctx).role = role_name(); + setState(1121); + match(DROP); + setState(1122); + match(USER); + setState(1123); + ((Alter_group_stmtContext)_localctx).users = identifier_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1125); + match(ALTER); + setState(1126); + match(GROUP); + setState(1127); + ((Alter_group_stmtContext)_localctx).group_name = identifier(0); + setState(1128); + match(RENAME); + setState(1129); + match(TO); + setState(1130); + ((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(1204); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1134); + match(ALTER); + setState(1135); + match(INDEX); + setState(1138); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1136); + match(IF); + setState(1137); + match(EXISTS); + } + } + + setState(1140); + ((Alter_index_stmtContext)_localctx).name = identifier(0); + setState(1141); + match(RENAME); + setState(1142); + match(TO); + setState(1143); + ((Alter_index_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1145); + match(ALTER); + setState(1146); + match(INDEX); + setState(1149); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1147); + match(IF); + setState(1148); + match(EXISTS); + } + } + + setState(1151); + ((Alter_index_stmtContext)_localctx).name = identifier(0); + setState(1152); + match(SET); + setState(1153); + match(TABLESPACE); + setState(1154); + ((Alter_index_stmtContext)_localctx).tablespace_name = identifier(0); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1156); + match(ALTER); + setState(1157); + match(INDEX); + setState(1158); + ((Alter_index_stmtContext)_localctx).name = identifier(0); + setState(1159); + match(DEPENDS); + setState(1160); + match(ON); + setState(1161); + match(EXTENSION); + setState(1162); + ((Alter_index_stmtContext)_localctx).extension_name = identifier(0); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1164); + match(ALTER); + setState(1165); + match(INDEX); + setState(1168); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1166); + match(IF); + setState(1167); + match(EXISTS); + } + } + + setState(1170); + ((Alter_index_stmtContext)_localctx).name = identifier(0); + setState(1171); + match(SET); + setState(1172); + match(OPEN_PAREN); + setState(1173); + option_list(); + setState(1174); + match(CLOSE_PAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1176); + match(ALTER); + setState(1177); + match(INDEX); + setState(1180); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1178); + match(IF); + setState(1179); + match(EXISTS); + } + } + + setState(1182); + match(RESET); + setState(1183); + match(OPEN_PAREN); + setState(1184); + identifier_list(); + setState(1185); + match(CLOSE_PAREN); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1187); + match(ALTER); + setState(1188); + match(INDEX); + setState(1189); + match(ALL); + setState(1190); + match(IN); + setState(1191); + match(TABLESPACE); + setState(1192); + ((Alter_index_stmtContext)_localctx).name = identifier(0); + setState(1196); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OWNED) { + { + setState(1193); + match(OWNED); + setState(1194); + match(BY); + setState(1195); + ((Alter_index_stmtContext)_localctx).roles = identifier_list(); + } + } + + setState(1198); + match(SET); + setState(1199); + match(TABLESPACE); + setState(1200); + ((Alter_index_stmtContext)_localctx).new_tablespace = identifier(0); + setState(1202); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOWAIT) { + { + setState(1201); + 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(1229); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1206); + match(ALTER); + setState(1208); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PROCEDURAL) { + { + setState(1207); + match(PROCEDURAL); + } + } + + setState(1210); + match(LANGUAGE); + setState(1211); + ((Alter_language_stmtContext)_localctx).name = identifier(0); + setState(1212); + match(RENAME); + setState(1213); + match(TO); + setState(1214); + ((Alter_language_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1216); + match(ALTER); + setState(1218); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PROCEDURAL) { + { + setState(1217); + match(PROCEDURAL); + } + } + + setState(1220); + match(LANGUAGE); + setState(1221); + ((Alter_language_stmtContext)_localctx).name = identifier(0); + setState(1222); + match(OWNER); + setState(1223); + match(TO); + setState(1227); + _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_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 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(1224); + ((Alter_language_stmtContext)_localctx).new_owner = identifier(0); + } + break; + case CURRENT_USER: + { + setState(1225); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(1226); + 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(1231); + match(ALTER); + setState(1232); + match(LARGE); + setState(1233); + match(OBJECT); + setState(1234); + ((Alter_large_object_stmtContext)_localctx).large_object_oid = match(INTEGER_LITERAL); + setState(1235); + match(OWNER); + setState(1236); + match(TO); + setState(1240); + _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_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 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(1237); + ((Alter_large_object_stmtContext)_localctx).new_owner = identifier(0); + } + break; + case CURRENT_USER: + { + setState(1238); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(1239); + 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(1242); + 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(1244); + 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(1279); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1246); + match(ALTER); + setState(1247); + match(OPERATOR); + setState(1248); + match(CLASS); + setState(1249); + ((Alter_operator_class_stmtContext)_localctx).name = identifier(0); + setState(1250); + match(USING); + setState(1251); + index_method(); + setState(1252); + match(RENAME); + setState(1253); + match(TO); + setState(1254); + ((Alter_operator_class_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1256); + match(ALTER); + setState(1257); + match(OPERATOR); + setState(1258); + match(CLASS); + setState(1259); + ((Alter_operator_class_stmtContext)_localctx).name = identifier(0); + setState(1260); + match(USING); + setState(1261); + index_method(); + setState(1262); + match(OWNER); + setState(1263); + match(TO); + setState(1267); + _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_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 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(1264); + ((Alter_operator_class_stmtContext)_localctx).new_owner = identifier(0); + } + break; + case CURRENT_USER: + { + setState(1265); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(1266); + match(SESSION_USER); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1269); + match(ALTER); + setState(1270); + match(OPERATOR); + setState(1271); + match(CLASS); + setState(1272); + ((Alter_operator_class_stmtContext)_localctx).name = identifier(0); + setState(1273); + match(USING); + setState(1274); + index_method(); + setState(1275); + match(SET); + setState(1276); + match(SCHEMA); + setState(1277); + ((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(1281); + 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(1310); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1283); + match(ALTER); + setState(1284); + match(POLICY); + setState(1285); + ((Alter_policy_stmtContext)_localctx).name = identifier(0); + setState(1286); + match(ON); + setState(1287); + ((Alter_policy_stmtContext)_localctx).table_name = identifier(0); + setState(1288); + match(RENAME); + setState(1289); + match(TO); + setState(1290); + ((Alter_policy_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1292); + match(ALTER); + setState(1293); + match(POLICY); + setState(1294); + ((Alter_policy_stmtContext)_localctx).name = identifier(0); + setState(1295); + match(ON); + setState(1296); + ((Alter_policy_stmtContext)_localctx).table_name = identifier(0); + setState(1299); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TO) { + { + setState(1297); + match(TO); + setState(1298); + ((Alter_policy_stmtContext)_localctx).roles = role_name_list(); + } + } + + setState(1303); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(1301); + match(USING); + setState(1302); + predicate(0); + } + } + + setState(1308); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(1305); + match(WITH); + setState(1306); + match(CHECK); + setState(1307); + 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(1364); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1312); + match(ALTER); + setState(1313); + match(PUBLICATION); + setState(1314); + ((Alter_publication_stmtContext)_localctx).name = identifier(0); + setState(1315); + match(ADD); + setState(1316); + match(TABLE); + setState(1318); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(1317); + match(ONLY); + } + } + + setState(1320); + ((Alter_publication_stmtContext)_localctx).table_names = identifier_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1322); + match(ALTER); + setState(1323); + match(PUBLICATION); + setState(1324); + ((Alter_publication_stmtContext)_localctx).name = identifier(0); + setState(1325); + match(SET); + setState(1326); + match(TABLE); + setState(1328); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(1327); + match(ONLY); + } + } + + setState(1330); + ((Alter_publication_stmtContext)_localctx).table_names = identifier_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1332); + match(ALTER); + setState(1333); + match(PUBLICATION); + setState(1334); + ((Alter_publication_stmtContext)_localctx).name = identifier(0); + setState(1335); + match(DROP); + setState(1336); + match(TABLE); + setState(1338); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(1337); + match(ONLY); + } + } + + setState(1340); + ((Alter_publication_stmtContext)_localctx).table_names = identifier_list(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1342); + match(ALTER); + setState(1343); + match(PUBLICATION); + setState(1344); + ((Alter_publication_stmtContext)_localctx).name = identifier(0); + setState(1345); + match(SET); + setState(1346); + match(OPEN_PAREN); + setState(1347); + option_list(); + setState(1348); + match(CLOSE_PAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1350); + match(ALTER); + setState(1351); + match(PUBLICATION); + setState(1352); + ((Alter_publication_stmtContext)_localctx).name = identifier(0); + setState(1353); + match(OWNER); + setState(1354); + match(TO); + setState(1355); + ((Alter_publication_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1357); + match(ALTER); + setState(1358); + match(PUBLICATION); + setState(1359); + ((Alter_publication_stmtContext)_localctx).name = identifier(0); + setState(1360); + match(RENAME); + setState(1361); + match(TO); + setState(1362); + ((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(1391); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SUPERUSER: + enterOuterAlt(_localctx, 1); + { + setState(1366); + match(SUPERUSER); + } + break; + case NOSUPERUSER: + enterOuterAlt(_localctx, 2); + { + setState(1367); + match(NOSUPERUSER); + } + break; + case CREATEDB: + enterOuterAlt(_localctx, 3); + { + setState(1368); + match(CREATEDB); + } + break; + case NOCREATEDB: + enterOuterAlt(_localctx, 4); + { + setState(1369); + match(NOCREATEDB); + } + break; + case CREATEROLE: + enterOuterAlt(_localctx, 5); + { + setState(1370); + match(CREATEROLE); + } + break; + case NOCREATEROLE: + enterOuterAlt(_localctx, 6); + { + setState(1371); + match(NOCREATEROLE); + } + break; + case INHERIT: + enterOuterAlt(_localctx, 7); + { + setState(1372); + match(INHERIT); + } + break; + case NOINHERIT: + enterOuterAlt(_localctx, 8); + { + setState(1373); + match(NOINHERIT); + } + break; + case LOGIN: + enterOuterAlt(_localctx, 9); + { + setState(1374); + match(LOGIN); + } + break; + case NOLOGIN: + enterOuterAlt(_localctx, 10); + { + setState(1375); + match(NOLOGIN); + } + break; + case REPLICATION: + enterOuterAlt(_localctx, 11); + { + setState(1376); + match(REPLICATION); + } + break; + case NOREPLICATION: + enterOuterAlt(_localctx, 12); + { + setState(1377); + match(NOREPLICATION); + } + break; + case BYPASSRLS: + enterOuterAlt(_localctx, 13); + { + setState(1378); + match(BYPASSRLS); + } + break; + case NOBYPASSRLS: + enterOuterAlt(_localctx, 14); + { + setState(1379); + match(NOBYPASSRLS); + } + break; + case CONNECTION: + enterOuterAlt(_localctx, 15); + { + setState(1380); + match(CONNECTION); + setState(1381); + match(LIMIT); + setState(1382); + ((Alter_role_optionsContext)_localctx).connlimit = match(INTEGER); + } + break; + case ENCRYPTED: + case PASSWORD: + enterOuterAlt(_localctx, 16); + { + setState(1384); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENCRYPTED) { + { + setState(1383); + match(ENCRYPTED); + } + } + + setState(1386); + match(PASSWORD); + setState(1387); + match(SINGLEQ_STRING_LITERAL); + } + break; + case VALID: + enterOuterAlt(_localctx, 17); + { + setState(1388); + match(VALID); + setState(1389); + match(UNTIL); + setState(1390); + 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(1471); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1393); + match(ALTER); + setState(1394); + match(ROLE); + setState(1395); + ((Alter_role_stmtContext)_localctx).role = role_name(); + setState(1397); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(1396); + match(WITH); + } + } + + setState(1400); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1399); + ((Alter_role_stmtContext)_localctx).options = alter_role_options(); + } + } + setState(1402); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==CONNECTION || _la==CREATEDB || _la==ENCRYPTED || _la==NOCREATEDB || _la==PASSWORD || ((((_la - 628)) & ~0x3f) == 0 && ((1L << (_la - 628)) & 1099243192321L) != 0) ); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1404); + match(ALTER); + setState(1405); + match(ROLE); + setState(1406); + ((Alter_role_stmtContext)_localctx).name = name_(); + setState(1407); + match(RENAME); + setState(1408); + match(TO); + setState(1409); + ((Alter_role_stmtContext)_localctx).new_name = name_(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1411); + match(ALTER); + setState(1412); + match(ROLE); + setState(1415); + _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_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 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(1413); + ((Alter_role_stmtContext)_localctx).role = role_name(); + } + break; + case ALL: + { + setState(1414); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1420); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(1417); + match(IN); + setState(1418); + match(DATABASE); + setState(1419); + ((Alter_role_stmtContext)_localctx).database_name = name_(); + } + } + + setState(1422); + match(SET); + setState(1423); + ((Alter_role_stmtContext)_localctx).configuration_parameter = identifier(0); + setState(1424); + _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(1427); + _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_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 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 NUMERIC_LITERAL: + case INTEGER_LITERAL: + case SINGLEQ_STRING_LITERAL: + case DOUBLEQ_STRING_LITERAL: + case IDENTIFIER: + case IDENTIFIER_UNICODE: + { + setState(1425); + ((Alter_role_stmtContext)_localctx).value = param_value(); + } + break; + case DEFAULT: + { + setState(1426); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1429); + match(ALTER); + setState(1430); + match(ROLE); + setState(1433); + _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_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 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(1431); + ((Alter_role_stmtContext)_localctx).role = role_name(); + } + break; + case ALL: + { + setState(1432); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1438); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(1435); + match(IN); + setState(1436); + match(DATABASE); + setState(1437); + ((Alter_role_stmtContext)_localctx).database_name = name_(); + } + } + + setState(1440); + match(SET); + setState(1441); + ((Alter_role_stmtContext)_localctx).configuration_parameter = identifier(0); + setState(1442); + match(FROM); + setState(1443); + match(CURRENT); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1445); + match(ALTER); + setState(1446); + match(ROLE); + setState(1449); + _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_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 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(1447); + ((Alter_role_stmtContext)_localctx).role = role_name(); + } + break; + case ALL: + { + setState(1448); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1454); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(1451); + match(IN); + setState(1452); + match(DATABASE); + setState(1453); + ((Alter_role_stmtContext)_localctx).database_name = name_(); + } + } + + setState(1456); + match(RESET); + setState(1457); + ((Alter_role_stmtContext)_localctx).configuration_parameter = identifier(0); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1458); + match(ALTER); + setState(1459); + match(ROLE); + setState(1462); + _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_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 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(1460); + ((Alter_role_stmtContext)_localctx).role = role_name(); + } + break; + case ALL: + { + setState(1461); + match(ALL); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1467); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(1464); + match(IN); + setState(1465); + match(DATABASE); + setState(1466); + ((Alter_role_stmtContext)_localctx).database_name = name_(); + } + } + + setState(1469); + match(RESET); + setState(1470); + 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(1473); + match(ALTER); + setState(1474); + match(RULE); + setState(1475); + ((Alter_rule_stmtContext)_localctx).name = name_(); + setState(1476); + match(ON); + setState(1477); + ((Alter_rule_stmtContext)_localctx).table_name = identifier(0); + setState(1478); + match(RENAME); + setState(1479); + match(TO); + setState(1480); + ((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(1499); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1482); + match(ALTER); + setState(1483); + match(SCHEMA); + setState(1484); + ((Alter_schema_stmtContext)_localctx).name = identifier(0); + setState(1485); + match(RENAME); + setState(1486); + match(TO); + setState(1487); + ((Alter_schema_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1489); + match(ALTER); + setState(1490); + match(SCHEMA); + setState(1491); + ((Alter_schema_stmtContext)_localctx).name = identifier(0); + setState(1492); + match(OWNER); + setState(1493); + match(TO); + setState(1497); + _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_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 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(1494); + ((Alter_schema_stmtContext)_localctx).new_owner = identifier(0); + } + break; + case CURRENT_USER: + { + setState(1495); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(1496); + 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(1501); + match(ALTER); + setState(1502); + match(SEQUENCE); + setState(1505); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1503); + match(IF); + setState(1504); + match(EXISTS); + } + } + + setState(1507); + ((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(1510); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { + case 1: + { + setState(1509); + _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(1512); + ((Alter_server_options_listContext)_localctx).option = identifier(0); + setState(1514); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 119L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3341673120384679935L) != 0)) { + { + setState(1513); + ((Alter_server_options_listContext)_localctx).value = param_value(); + } + } + + } + setState(1526); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1516); + match(COMMA); + setState(1518); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) { + case 1: + { + setState(1517); + _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(1520); + ((Alter_server_options_listContext)_localctx).option = identifier(0); + setState(1522); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 119L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3341673120384679935L) != 0)) { + { + setState(1521); + ((Alter_server_options_listContext)_localctx).value = param_value(); + } + } + + } + } + setState(1528); + _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(1559); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1529); + match(ALTER); + setState(1530); + match(SERVER); + setState(1531); + ((Alter_server_stmtContext)_localctx).name = identifier(0); + setState(1543); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { + case 1: + { + { + setState(1532); + match(VERSION); + setState(1533); + match(SINGLEQ_STRING_LITERAL); + } + } + break; + case 2: + { + { + setState(1536); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VERSION) { + { + setState(1534); + match(VERSION); + setState(1535); + match(SINGLEQ_STRING_LITERAL); + } + } + + { + setState(1538); + match(OPTIONS); + setState(1539); + match(OPEN_PAREN); + setState(1540); + alter_server_options_list(); + setState(1541); + match(CLOSE_PAREN); + } + } + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1545); + match(ALTER); + setState(1546); + match(SERVER); + setState(1547); + ((Alter_server_stmtContext)_localctx).name = identifier(0); + setState(1548); + match(OWNER); + setState(1549); + match(TO); + setState(1550); + ((Alter_server_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1552); + match(ALTER); + setState(1553); + match(SERVER); + setState(1554); + ((Alter_server_stmtContext)_localctx).name = identifier(0); + setState(1555); + match(RENAME); + setState(1556); + match(TO); + setState(1557); + ((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(1585); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1561); + match(ALTER); + setState(1562); + match(STATISTICS); + setState(1563); + ((Alter_statistics_stmtContext)_localctx).name = identifier(0); + setState(1564); + match(OWNER); + setState(1565); + match(TO); + setState(1569); + _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_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 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(1566); + ((Alter_statistics_stmtContext)_localctx).new_owner = identifier(0); + } + break; + case CURRENT_USER: + { + setState(1567); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(1568); + match(SESSION_USER); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1571); + match(ALTER); + setState(1572); + match(STATISTICS); + setState(1573); + ((Alter_statistics_stmtContext)_localctx).name = identifier(0); + setState(1574); + match(RENAME); + setState(1575); + match(TO); + setState(1576); + ((Alter_statistics_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1578); + match(ALTER); + setState(1579); + match(STATISTICS); + setState(1580); + ((Alter_statistics_stmtContext)_localctx).name = identifier(0); + setState(1581); + match(SET); + setState(1582); + match(SCHEMA); + setState(1583); + ((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(1650); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1587); + match(ALTER); + setState(1588); + match(SUBSCRIPTION); + setState(1589); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1590); + match(CONNECTION); + setState(1591); + ((Alter_subscription_stmtContext)_localctx).conninfo = param_value(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1593); + match(ALTER); + setState(1594); + match(SUBSCRIPTION); + setState(1595); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1596); + match(SET); + setState(1597); + match(PUBLICATION); + setState(1598); + ((Alter_subscription_stmtContext)_localctx).publication_name = name_list(); + setState(1604); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(1599); + match(WITH); + setState(1600); + match(OPEN_PAREN); + setState(1601); + option_list(); + setState(1602); + match(CLOSE_PAREN); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1606); + match(ALTER); + setState(1607); + match(SUBSCRIPTION); + setState(1608); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1609); + match(REFRESH); + setState(1610); + match(PUBLICATION); + setState(1616); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(1611); + match(WITH); + setState(1612); + match(OPEN_PAREN); + setState(1613); + option_list(); + setState(1614); + match(CLOSE_PAREN); + } + } + + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1618); + match(ALTER); + setState(1619); + match(SUBSCRIPTION); + setState(1620); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1621); + match(ENABLE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1623); + match(ALTER); + setState(1624); + match(SUBSCRIPTION); + setState(1625); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1626); + match(DISABLE); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1628); + match(ALTER); + setState(1629); + match(SUBSCRIPTION); + setState(1630); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1631); + match(SET); + setState(1632); + match(OPEN_PAREN); + setState(1633); + option_list(); + setState(1634); + match(CLOSE_PAREN); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1636); + match(ALTER); + setState(1637); + match(SUBSCRIPTION); + setState(1638); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1639); + match(OWNER); + setState(1640); + match(TO); + setState(1641); + ((Alter_subscription_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1643); + match(ALTER); + setState(1644); + match(SUBSCRIPTION); + setState(1645); + ((Alter_subscription_stmtContext)_localctx).name = identifier(0); + setState(1646); + match(RENAME); + setState(1647); + match(TO); + setState(1648); + ((Alter_subscription_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_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(1666); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1652); + match(ALTER); + setState(1653); + match(SYSTEM); + setState(1654); + match(SET); + setState(1655); + ((Alter_system_stmtContext)_localctx).param = match(IDENTIFIER); + setState(1656); + _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(1657); + ((Alter_system_stmtContext)_localctx).value = param_value(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1658); + match(ALTER); + setState(1659); + match(SYSTEM); + setState(1660); + match(RESET); + setState(1661); + ((Alter_system_stmtContext)_localctx).param = match(IDENTIFIER); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1662); + match(ALTER); + setState(1663); + match(SYSTEM); + setState(1664); + match(RESET); + setState(1665); + 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(1668); + 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(1703); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,108,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1670); + match(ALTER); + setState(1671); + match(TABLESPACE); + setState(1672); + ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); + setState(1673); + match(RENAME); + setState(1674); + match(TO); + setState(1675); + ((Alter_tablespace_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1677); + match(ALTER); + setState(1678); + match(TABLESPACE); + setState(1679); + ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); + setState(1680); + match(OWNER); + setState(1681); + match(TO); + setState(1685); + _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_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 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(1682); + ((Alter_tablespace_stmtContext)_localctx).new_owner = identifier(0); + } + break; + case CURRENT_USER: + { + setState(1683); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(1684); + match(SESSION_USER); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1687); + match(ALTER); + setState(1688); + match(TABLESPACE); + setState(1689); + ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); + setState(1690); + match(SET); + setState(1691); + match(OPEN_PAREN); + setState(1692); + option_list(); + setState(1693); + match(CLOSE_PAREN); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1695); + match(ALTER); + setState(1696); + match(TABLESPACE); + setState(1697); + ((Alter_tablespace_stmtContext)_localctx).name = identifier(0); + setState(1698); + match(RESET); + setState(1699); + match(OPEN_PAREN); + setState(1700); + identifier_list(); + setState(1701); + 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(1796); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1705); + match(ALTER); + setState(1706); + match(TEXT); + setState(1707); + match(SEARCH); + setState(1708); + match(CONFIGURATION); + setState(1709); + ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); + setState(1710); + match(ADD); + setState(1711); + match(MAPPING); + setState(1712); + match(FOR); + setState(1713); + ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); + setState(1714); + match(WITH); + setState(1715); + ((Alter_text_search_config_stmtContext)_localctx).dictionary_names = identifier_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1717); + match(ALTER); + setState(1718); + match(TEXT); + setState(1719); + match(SEARCH); + setState(1720); + match(CONFIGURATION); + setState(1721); + ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); + setState(1722); + match(ALTER); + setState(1723); + match(MAPPING); + setState(1724); + match(FOR); + setState(1725); + ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); + setState(1726); + match(WITH); + setState(1727); + ((Alter_text_search_config_stmtContext)_localctx).dictionary_names = identifier_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1729); + match(ALTER); + setState(1730); + match(TEXT); + setState(1731); + match(SEARCH); + setState(1732); + match(CONFIGURATION); + setState(1733); + ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); + setState(1734); + match(ALTER); + setState(1735); + match(MAPPING); + setState(1736); + match(REPLACE); + setState(1737); + ((Alter_text_search_config_stmtContext)_localctx).old_dictionary = identifier(0); + setState(1738); + match(WITH); + setState(1739); + ((Alter_text_search_config_stmtContext)_localctx).new_dictionary = identifier(0); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1741); + match(ALTER); + setState(1742); + match(TEXT); + setState(1743); + match(SEARCH); + setState(1744); + match(CONFIGURATION); + setState(1745); + ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); + setState(1746); + match(ALTER); + setState(1747); + match(MAPPING); + setState(1748); + match(FOR); + setState(1749); + ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); + 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 5: + enterOuterAlt(_localctx, 5); + { + 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(DROP); + setState(1761); + match(MAPPING); + setState(1764); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(1762); + match(IF); + setState(1763); + match(EXISTS); + } + } + + setState(1766); + match(FOR); + setState(1767); + ((Alter_text_search_config_stmtContext)_localctx).token_types = identifier_list(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + 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(RENAME); + setState(1775); + match(TO); + setState(1776); + ((Alter_text_search_config_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1778); + match(ALTER); + setState(1779); + match(TEXT); + setState(1780); + match(SEARCH); + setState(1781); + match(CONFIGURATION); + setState(1782); + ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); + setState(1783); + match(OWNER); + setState(1784); + match(TO); + setState(1785); + ((Alter_text_search_config_stmtContext)_localctx).new_owner = role_name(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1787); + match(ALTER); + setState(1788); + match(TEXT); + setState(1789); + match(SEARCH); + setState(1790); + match(CONFIGURATION); + setState(1791); + ((Alter_text_search_config_stmtContext)_localctx).name = identifier(0); + setState(1792); + match(SET); + setState(1793); + match(SCHEMA); + setState(1794); + ((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(1798); + 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(1800); + 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(1820); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1802); + match(ALTER); + setState(1803); + match(TEXT); + setState(1804); + match(SEARCH); + setState(1805); + match(TEMPLATE); + setState(1806); + ((Alter_text_search_template_stmtContext)_localctx).name = identifier(0); + setState(1807); + match(RENAME); + setState(1808); + match(TO); + setState(1809); + ((Alter_text_search_template_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1811); + match(ALTER); + setState(1812); + match(TEXT); + setState(1813); + match(SEARCH); + setState(1814); + match(TEMPLATE); + setState(1815); + ((Alter_text_search_template_stmtContext)_localctx).name = identifier(0); + setState(1816); + match(SET); + setState(1817); + match(SCHEMA); + setState(1818); + ((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(1841); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1822); + match(ALTER); + setState(1823); + match(TRIGGER); + setState(1824); + ((Alter_trigger_stmtContext)_localctx).name = identifier(0); + setState(1825); + match(ON); + setState(1826); + ((Alter_trigger_stmtContext)_localctx).table_name = identifier(0); + setState(1827); + match(RENAME); + setState(1828); + match(TO); + setState(1829); + ((Alter_trigger_stmtContext)_localctx).new_name = identifier(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1831); + match(ALTER); + setState(1832); + match(TRIGGER); + setState(1833); + ((Alter_trigger_stmtContext)_localctx).name = identifier(0); + setState(1834); + match(ON); + setState(1835); + ((Alter_trigger_stmtContext)_localctx).table_name = identifier(0); + setState(1836); + match(DEPENDS); + setState(1837); + match(ON); + setState(1838); + match(EXTENSION); + setState(1839); + ((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(1843); + 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(1845); + 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(1847); + match(ALTER); + setState(1848); + match(USER); + setState(1849); + match(MAPPING); + setState(1850); + match(FOR); + setState(1851); + ((Alter_user_mapping_stmtContext)_localctx).user = role_name(); + setState(1852); + match(SERVER); + setState(1853); + ((Alter_user_mapping_stmtContext)_localctx).server_name = identifier(0); + setState(1854); + match(OPTIONS); + { + setState(1855); + match(OPEN_PAREN); + setState(1856); + alter_server_options_list(); + setState(1857); + 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(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 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(1861); + match(ANALYZE); + setState(1863); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VERBOSE) { + { + setState(1862); + match(VERBOSE); + } + } + + setState(1865); + table_name_(); + setState(1870); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(1866); + match(OPEN_PAREN); + setState(1867); + name_list(); + setState(1868); + 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(1872); + 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(1874); + 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(1876); + 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(1878); + 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(1880); + 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(1882); + 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(1923); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1884); + create_access_method_stmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1885); + create_aggregate_stmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1886); + create_cast_stmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1887); + create_collation_stmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1888); + create_conversion_stmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1889); + create_database_stmt(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1890); + create_domain_stmt(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1891); + create_event_trigger_stmt(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1892); + create_foreign_data_stmt(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1893); + create_foreign_table_stmt(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1894); + create_function_stmt(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1895); + create_group_stmt(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(1896); + create_index_stmt(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(1897); + create_language_stmt(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(1898); + create_materialized_view_stmt(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(1899); + create_operator_stmt(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(1900); + create_operator_class_stmt(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(1901); + create_operator_family_stmt(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(1902); + create_policy_stmt(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(1903); + create_role_stmt(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(1904); + create_rule_stmt(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(1905); + create_schema_stmt(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(1906); + create_sequence_stmt(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(1907); + create_server_stmt(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(1908); + create_statistics_stmt(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(1909); + create_subscription_stmt(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(1910); + create_table_stmt(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(1911); + create_table_as_stmt(); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(1912); + create_tablespace_stmt(); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(1913); + create_text_search_config_stmt(); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(1914); + create_text_search_dict_stmt(); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(1915); + create_text_search_parser_stmt(); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(1916); + create_text_search_template_stmt(); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(1917); + create_transform_stmt(); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(1918); + create_trigger_stmt(); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(1919); + create_type_stmt(); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(1920); + create_user_stmt(); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(1921); + create_user_mapping_stmt(); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(1922); + 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(1925); + match(CREATE); + setState(1926); + match(ACCESS); + setState(1927); + match(METHOD); + setState(1928); + name_(); + setState(1929); + match(TYPE); + setState(1930); + match(INDEX); + setState(1931); + match(HANDLER); + setState(1932); + 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(2216); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + { + setState(1934); + match(CREATE); + setState(1935); + match(AGGREGATE); + setState(1936); + name_(); + setState(1937); + match(OPEN_PAREN); + setState(1939); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN || _la==VARIADIC) { + { + setState(1938); + _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(1942); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { + case 1: + { + setState(1941); + name_(); + } + break; + } + setState(1944); + data_type_list(); + setState(1945); + match(CLOSE_PAREN); + setState(1946); + match(OPEN_PAREN); + setState(1947); + match(SFUNC); + setState(1948); + match(EQUAL); + setState(1949); + identifier(0); + setState(1950); + match(COMMA); + setState(1951); + match(STYPE); + setState(1952); + match(EQUAL); + setState(1953); + identifier(0); + setState(1958); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { + case 1: + { + setState(1954); + match(COMMA); + setState(1955); + match(SSPACE); + setState(1956); + match(EQUAL); + setState(1957); + match(INTEGER_LITERAL); + } + break; + } + setState(1964); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { + case 1: + { + setState(1960); + match(COMMA); + setState(1961); + match(FINALFUNC); + setState(1962); + match(EQUAL); + setState(1963); + identifier(0); + } + break; + } + setState(1968); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) { + case 1: + { + setState(1966); + match(COMMA); + setState(1967); + match(FINALFUNC_EXTRA); + } + break; + } + setState(1974); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { + case 1: + { + setState(1970); + match(COMMA); + setState(1971); + match(COMBINEFUNC); + setState(1972); + match(EQUAL); + setState(1973); + identifier(0); + } + break; + } + setState(1980); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { + case 1: + { + setState(1976); + match(COMMA); + setState(1977); + match(SERIALFUNC); + setState(1978); + match(EQUAL); + setState(1979); + identifier(0); + } + break; + } + setState(1986); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) { + case 1: + { + setState(1982); + match(COMMA); + setState(1983); + match(DESERIALFUNC); + setState(1984); + match(EQUAL); + setState(1985); + identifier(0); + } + break; + } + setState(1992); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { + case 1: + { + setState(1988); + match(COMMA); + setState(1989); + match(INITCOND); + setState(1990); + match(EQUAL); + setState(1991); + expr(0); + } + break; + } + setState(1998); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { + case 1: + { + setState(1994); + match(COMMA); + setState(1995); + match(MSFUNC); + setState(1996); + match(EQUAL); + setState(1997); + identifier(0); + } + break; + } + setState(2004); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { + case 1: + { + setState(2000); + match(COMMA); + setState(2001); + match(MINVFUNC); + setState(2002); + match(EQUAL); + setState(2003); + identifier(0); + } + break; + } + setState(2010); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { + case 1: + { + setState(2006); + match(COMMA); + setState(2007); + match(MSTYPE); + setState(2008); + match(EQUAL); + setState(2009); + identifier(0); + } + break; + } + setState(2016); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { + case 1: + { + setState(2012); + match(COMMA); + setState(2013); + match(MSSPACE); + setState(2014); + match(EQUAL); + setState(2015); + match(INTEGER_LITERAL); + } + break; + } + setState(2022); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { + case 1: + { + setState(2018); + match(COMMA); + setState(2019); + match(MFINALFUNC); + setState(2020); + match(EQUAL); + setState(2021); + identifier(0); + } + break; + } + setState(2026); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { + case 1: + { + setState(2024); + match(COMMA); + setState(2025); + match(MFINALFUNC_EXTRA); + } + break; + } + setState(2032); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { + case 1: + { + setState(2028); + match(COMMA); + setState(2029); + match(MINITCOND); + setState(2030); + match(EQUAL); + setState(2031); + identifier(0); + } + break; + } + setState(2038); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { + case 1: + { + setState(2034); + match(COMMA); + setState(2035); + match(SORTOP); + setState(2036); + match(EQUAL); + setState(2037); + identifier(0); + } + break; + } + setState(2044); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2040); + match(COMMA); + setState(2041); + match(PARALLEL); + setState(2042); + match(EQUAL); + setState(2043); + _la = _input.LA(1); + if ( !(((((_la - 687)) & ~0x3f) == 0 && ((1L << (_la - 687)) & 7L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(2046); + match(CLOSE_PAREN); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + { + setState(2048); + match(CREATE); + setState(2049); + match(AGGREGATE); + setState(2050); + name_(); + setState(2051); + match(OPEN_PAREN); + setState(2059); + _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)) & -7658391026909839363L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3314651522620456959L) != 0)) { + { + setState(2053); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN || _la==VARIADIC) { + { + setState(2052); + _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(2056); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { + case 1: + { + setState(2055); + name_(); + } + break; + } + setState(2058); + data_type_list(); + } + } + + setState(2061); + match(ORDER); + setState(2062); + match(BY); + setState(2064); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN || _la==VARIADIC) { + { + setState(2063); + _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(2067); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { + case 1: + { + setState(2066); + name_(); + } + break; + } + setState(2069); + data_type_list(); + setState(2070); + match(CLOSE_PAREN); + setState(2071); + match(OPEN_PAREN); + setState(2072); + match(SFUNC); + setState(2073); + match(EQUAL); + setState(2074); + identifier(0); + setState(2075); + match(COMMA); + setState(2076); + match(STYPE); + setState(2077); + match(EQUAL); + setState(2078); + identifier(0); + setState(2083); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { + case 1: + { + setState(2079); + match(COMMA); + setState(2080); + match(SSPACE); + setState(2081); + match(EQUAL); + setState(2082); + match(INTEGER_LITERAL); + } + break; + } + setState(2089); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { + case 1: + { + setState(2085); + match(COMMA); + setState(2086); + match(FINALFUNC); + setState(2087); + match(EQUAL); + setState(2088); + identifier(0); + } + break; + } + setState(2093); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { + case 1: + { + setState(2091); + match(COMMA); + setState(2092); + match(FINALFUNC_EXTRA); + } + break; + } + setState(2099); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { + case 1: + { + setState(2095); + match(COMMA); + setState(2096); + match(INITCOND); + setState(2097); + match(EQUAL); + setState(2098); + expr(0); + } + break; + } + setState(2105); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { + case 1: + { + setState(2101); + match(COMMA); + setState(2102); + match(PARALLEL); + setState(2103); + match(EQUAL); + setState(2104); + _la = _input.LA(1); + if ( !(((((_la - 687)) & ~0x3f) == 0 && ((1L << (_la - 687)) & 7L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(2109); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2107); + match(COMMA); + setState(2108); + match(HYPOTHETICAL); + } + } + + setState(2111); + match(CLOSE_PAREN); + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + { + setState(2113); + match(CREATE); + setState(2114); + match(AGGREGATE); + setState(2115); + name_(); + setState(2116); + match(OPEN_PAREN); + setState(2117); + match(BASETYPE); + setState(2118); + match(EQUAL); + setState(2119); + data_type(); + setState(2120); + match(COMMA); + setState(2121); + match(SFUNC); + setState(2122); + match(EQUAL); + setState(2123); + identifier(0); + setState(2124); + match(COMMA); + setState(2125); + match(STYPE); + setState(2126); + match(EQUAL); + setState(2127); + identifier(0); + setState(2132); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) { + case 1: + { + setState(2128); + match(COMMA); + setState(2129); + match(SSPACE); + setState(2130); + match(EQUAL); + setState(2131); + match(INTEGER_LITERAL); + } + break; + } + setState(2138); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { + case 1: + { + setState(2134); + match(COMMA); + setState(2135); + match(FINALFUNC); + setState(2136); + match(EQUAL); + setState(2137); + identifier(0); + } + break; + } + setState(2142); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) { + case 1: + { + setState(2140); + match(COMMA); + setState(2141); + match(FINALFUNC_EXTRA); + } + break; + } + setState(2148); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { + case 1: + { + setState(2144); + match(COMMA); + setState(2145); + match(COMBINEFUNC); + setState(2146); + match(EQUAL); + setState(2147); + identifier(0); + } + break; + } + setState(2154); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) { + case 1: + { + setState(2150); + match(COMMA); + setState(2151); + match(SERIALFUNC); + setState(2152); + match(EQUAL); + setState(2153); + identifier(0); + } + break; + } + setState(2160); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { + case 1: + { + setState(2156); + match(COMMA); + setState(2157); + match(DESERIALFUNC); + setState(2158); + match(EQUAL); + setState(2159); + identifier(0); + } + break; + } + setState(2166); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) { + case 1: + { + setState(2162); + match(COMMA); + setState(2163); + match(INITCOND); + setState(2164); + match(EQUAL); + setState(2165); + expr(0); + } + break; + } + setState(2172); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { + case 1: + { + setState(2168); + match(COMMA); + setState(2169); + match(MSFUNC); + setState(2170); + match(EQUAL); + setState(2171); + identifier(0); + } + break; + } + setState(2178); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) { + case 1: + { + setState(2174); + match(COMMA); + setState(2175); + match(MINVFUNC); + setState(2176); + match(EQUAL); + setState(2177); + identifier(0); + } + break; + } + setState(2184); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { + case 1: + { + setState(2180); + match(COMMA); + setState(2181); + match(MSTYPE); + setState(2182); + match(EQUAL); + setState(2183); + identifier(0); + } + break; + } + setState(2190); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) { + case 1: + { + setState(2186); + match(COMMA); + setState(2187); + match(MSSPACE); + setState(2188); + match(EQUAL); + setState(2189); + match(INTEGER_LITERAL); + } + break; + } + setState(2196); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { + case 1: + { + setState(2192); + match(COMMA); + setState(2193); + match(MFINALFUNC); + setState(2194); + match(EQUAL); + setState(2195); + identifier(0); + } + break; + } + setState(2200); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { + case 1: + { + setState(2198); + match(COMMA); + setState(2199); + match(MFINALFUNC_EXTRA); + } + break; + } + setState(2206); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) { + case 1: + { + setState(2202); + match(COMMA); + setState(2203); + match(MINITCOND); + setState(2204); + match(EQUAL); + setState(2205); + identifier(0); + } + break; + } + setState(2212); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2208); + match(COMMA); + setState(2209); + match(SORTOP); + setState(2210); + match(EQUAL); + setState(2211); + identifier(0); + } + } + + setState(2214); + 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(2218); + match(CREATE); + setState(2219); + match(CAST); + setState(2220); + match(OPEN_PAREN); + setState(2221); + data_type(); + setState(2222); + match(AS); + setState(2223); + data_type(); + setState(2224); + match(CLOSE_PAREN); + setState(2238); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { + case 1: + { + { + setState(2225); + match(WITH); + setState(2226); + match(FUNCTION); + setState(2227); + identifier(0); + setState(2232); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(2228); + match(OPEN_PAREN); + setState(2229); + data_type_list(); + setState(2230); + match(CLOSE_PAREN); + } + } + + } + } + break; + case 2: + { + { + setState(2234); + match(WITHOUT); + setState(2235); + match(FUNCTION); + } + } + break; + case 3: + { + { + setState(2236); + match(WITH); + setState(2237); + match(INOUT); + } + } + break; + } + setState(2244); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { + case 1: + { + setState(2240); + match(AS); + setState(2241); + match(ASSIGNMENT); + } + break; + case 2: + { + setState(2242); + match(AS); + setState(2243); + 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(2264); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LOCALE: + enterOuterAlt(_localctx, 1); + { + setState(2246); + match(LOCALE); + setState(2247); + match(EQUAL); + setState(2248); + expr(0); + } + break; + case LC_COLLATE: + enterOuterAlt(_localctx, 2); + { + setState(2249); + match(LC_COLLATE); + setState(2250); + match(EQUAL); + setState(2251); + expr(0); + } + break; + case LC_CTYPE: + enterOuterAlt(_localctx, 3); + { + setState(2252); + match(LC_CTYPE); + setState(2253); + match(EQUAL); + setState(2254); + expr(0); + } + break; + case PROVIDER: + enterOuterAlt(_localctx, 4); + { + setState(2255); + match(PROVIDER); + setState(2256); + match(EQUAL); + setState(2257); + expr(0); + } + break; + case VERSION: + enterOuterAlt(_localctx, 5); + { + setState(2258); + match(VERSION); + setState(2259); + match(EQUAL); + setState(2260); + expr(0); + } + break; + case DOUBLEQ_STRING_LITERAL: + enterOuterAlt(_localctx, 6); + { + setState(2261); + match(DOUBLEQ_STRING_LITERAL); + setState(2262); + match(EQUAL); + setState(2263); + 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(2266); + create_collation_opt(); + setState(2271); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2267); + match(COMMA); + setState(2268); + create_collation_opt(); + } + } + setState(2273); + _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(2297); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + { + setState(2274); + match(CREATE); + setState(2275); + match(COLLATION); + setState(2279); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(2276); + match(IF); + setState(2277); + match(NOT); + setState(2278); + match(EXISTS); + } + } + + setState(2281); + name_(); + setState(2282); + match(OPEN_PAREN); + setState(2283); + create_collation_opt_list(); + setState(2284); + match(CLOSE_PAREN); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + { + setState(2286); + match(CREATE); + setState(2287); + match(COLLATION); + setState(2291); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(2288); + match(IF); + setState(2289); + match(NOT); + setState(2290); + match(EXISTS); + } + } + + setState(2293); + name_(); + setState(2294); + match(FROM); + setState(2295); + 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(2299); + match(CREATE); + setState(2301); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(2300); + match(DEFAULT); + } + } + + setState(2303); + match(CONVERSION); + setState(2304); + identifier(0); + setState(2305); + match(FOR); + setState(2306); + match(SINGLEQ_STRING_LITERAL); + setState(2307); + match(TO); + setState(2308); + match(SINGLEQ_STRING_LITERAL); + setState(2309); + match(FROM); + setState(2310); + 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 INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } + public TerminalNode INTEGER_LITERAL(int i) { + return getToken(PostgreSqlParser.INTEGER_LITERAL, 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(2312); + match(CREATE); + setState(2313); + match(DATABASE); + setState(2314); + name_(); + { + setState(2316); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2315); + match(WITH); + } + } + + setState(2321); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OWNER) { + { + setState(2318); + match(OWNER); + setState(2319); + match(EQUAL); + setState(2320); + name_(); + } + } + + setState(2326); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TEMPLATE) { + { + setState(2323); + match(TEMPLATE); + setState(2324); + match(EQUAL); + setState(2325); + name_(); + } + } + + setState(2331); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENCODING) { + { + setState(2328); + match(ENCODING); + setState(2329); + match(EQUAL); + setState(2330); + name_(); + } + } + + setState(2336); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LC_COLLATE) { + { + setState(2333); + match(LC_COLLATE); + setState(2334); + match(EQUAL); + setState(2335); + name_(); + } + } + + setState(2341); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LC_CTYPE) { + { + setState(2338); + match(LC_CTYPE); + setState(2339); + match(EQUAL); + setState(2340); + name_(); + } + } + + setState(2346); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TABLESPACE) { + { + setState(2343); + match(TABLESPACE); + setState(2344); + match(EQUAL); + setState(2345); + name_(); + } + } + + setState(2351); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALLOW_CONNECTIONS) { + { + setState(2348); + match(ALLOW_CONNECTIONS); + setState(2349); + match(EQUAL); + setState(2350); + name_(); + } + } + + setState(2357); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONNECTION) { + { + setState(2353); + match(CONNECTION); + setState(2354); + match(LIMIT); + setState(2355); + match(EQUAL); + setState(2356); + match(INTEGER_LITERAL); + } + } + + setState(2362); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IS_TEMPLATE) { + { + setState(2359); + match(IS_TEMPLATE); + setState(2360); + match(EQUAL); + setState(2361); + 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 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(2366); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(2364); + match(CONSTRAINT); + setState(2365); + name_(); + } + } + + setState(2376); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOT: + { + setState(2368); + match(NOT); + setState(2369); + match(NULL); + } + break; + case NULL: + { + setState(2370); + match(NULL); + } + break; + case CHECK: + { + setState(2371); + match(CHECK); + setState(2372); + match(OPEN_PAREN); + setState(2373); + expr(0); + setState(2374); + 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(2378); + match(CREATE); + setState(2379); + match(DOMAIN); + setState(2380); + name_(); + setState(2382); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(2381); + match(AS); + } + } + + setState(2384); + data_type(); + setState(2392); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & 2147484673L) != 0) || _la==DEFAULT || _la==NOT || _la==NULL) { + { + setState(2390); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COLLATE: + { + { + setState(2385); + match(COLLATE); + setState(2386); + name_(); + } + } + break; + case DEFAULT: + { + { + setState(2387); + match(DEFAULT); + setState(2388); + expr(0); + } + } + break; + case CHECK: + case CONSTRAINT: + case NOT: + case NULL: + { + setState(2389); + domain_constraint(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(2394); + _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(2395); + ((Create_event_trigger_condContext)_localctx).filter_stmt = identifier(0); + setState(2396); + match(IN); + setState(2397); + match(OPEN_PAREN); + setState(2398); + match(SINGLEQ_STRING_LITERAL); + setState(2403); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2399); + match(COMMA); + setState(2400); + match(SINGLEQ_STRING_LITERAL); + } + } + setState(2405); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2406); + match(CLOSE_PAREN); + setState(2411); + _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(2407); + match(AND); + setState(2408); + create_event_trigger_cond(); + } + } + } + setState(2413); + _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(2414); + match(CREATE); + setState(2415); + match(EVENT); + setState(2416); + match(TRIGGER); + setState(2417); + ((Create_event_trigger_stmtContext)_localctx).trigger = identifier(0); + setState(2418); + match(ON); + setState(2419); + ((Create_event_trigger_stmtContext)_localctx).event = identifier(0); + setState(2422); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHEN) { + { + setState(2420); + match(WHEN); + setState(2421); + create_event_trigger_cond(); + } + } + + setState(2424); + match(EXECUTE); + setState(2425); + match(PROCEDURE); + setState(2426); + ((Create_event_trigger_stmtContext)_localctx).fn_name = identifier(0); + setState(2427); + match(OPEN_PAREN); + setState(2428); + 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(2430); + ((Create_foreign_data_optionsContext)_localctx).opt = name_(); + setState(2431); + match(SINGLEQ_STRING_LITERAL); + setState(2436); + _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(2432); + match(COMMA); + setState(2433); + create_foreign_data_options(); + } + } + } + setState(2438); + _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(2439); + match(CREATE); + setState(2440); + match(FOREIGN); + setState(2441); + match(DATA); + setState(2442); + match(WRAPPER); + setState(2443); + ((Create_foreign_data_stmtContext)_localctx).wrapper = identifier(0); + setState(2450); + _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(2448); + _errHandler.sync(this); + switch (_input.LA(1)) { + case HANDLER: + { + setState(2444); + match(HANDLER); + setState(2445); + ((Create_foreign_data_stmtContext)_localctx).handler = identifier(0); + } + break; + case NO: + { + setState(2446); + match(NO); + setState(2447); + match(HANDLER); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(2452); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,190,_ctx); + } + setState(2457); + _errHandler.sync(this); + switch (_input.LA(1)) { + case VALIDATOR: + { + setState(2453); + match(VALIDATOR); + setState(2454); + ((Create_foreign_data_stmtContext)_localctx).validator = identifier(0); + } + break; + case NO: + { + setState(2455); + match(NO); + setState(2456); + match(VALIDATOR); + } + break; + case EOF: + case OPTIONS: + case CLOSE_PAREN: + case SEMI: + break; + default: + break; + } + setState(2464); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPTIONS) { + { + setState(2459); + match(OPTIONS); + setState(2460); + match(OPEN_PAREN); + setState(2461); + ((Create_foreign_data_stmtContext)_localctx).opts = create_foreign_data_options(); + setState(2462); + 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(2466); + match(CREATE); + setState(2467); + match(FOREIGN); + setState(2468); + match(TABLE); + setState(2472); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(2469); + match(IF); + setState(2470); + match(NOT); + setState(2471); + match(EXISTS); + } + } + + setState(2474); + ((Create_foreign_table_stmtContext)_localctx).table_name_TODO = identifier(0); + setState(2475); + match(OPEN_PAREN); + setState(2476); + ((Create_foreign_table_stmtContext)_localctx).column_name_TODO = identifier(0); + setState(2477); + ((Create_foreign_table_stmtContext)_localctx).column_type = identifier(0); + setState(2483); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPTIONS) { + { + setState(2478); + match(OPTIONS); + setState(2479); + match(OPEN_PAREN); + setState(2480); + ((Create_foreign_table_stmtContext)_localctx).opts = create_foreign_data_options(); + setState(2481); + match(CLOSE_PAREN); + } + } + + setState(2487); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLLATE) { + { + setState(2485); + match(COLLATE); + setState(2486); + create_collation_opt(); + } + } + + setState(2489); + match(CLOSE_PAREN); + setState(2492); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INHERITS) { + { + setState(2490); + match(INHERITS); + setState(2491); + name_list(); + } + } + + setState(2494); + match(SERVER); + setState(2495); + ((Create_foreign_table_stmtContext)_localctx).server_name = name_(); + setState(2501); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPTIONS) { + { + setState(2496); + match(OPTIONS); + setState(2497); + match(OPEN_PAREN); + setState(2498); + ((Create_foreign_table_stmtContext)_localctx).opts = create_foreign_data_options(); + setState(2499); + 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(2503); + match(CREATE); + setState(2506); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OR) { + { + setState(2504); + match(OR); + setState(2505); + match(REPLACE); + } + } + + setState(2508); + match(FUNCTION); + setState(2509); + ((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(2511); + match(CREATE); + setState(2512); + match(GROUP); + setState(2513); + ((Create_group_stmtContext)_localctx).group = identifier(0); + setState(2555); + _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)) & 144150372447944705L) != 0) || ((((_la - 628)) & ~0x3f) == 0 && ((1L << (_la - 628)) & 68451565569L) != 0)) { + { + setState(2515); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2514); + match(WITH); + } + } + + setState(2551); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + setState(2551); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) { + case 1: + { + setState(2517); + match(SUPERUSER); + } + break; + case 2: + { + setState(2518); + match(NOSUPERUSER); + } + break; + case 3: + { + setState(2519); + match(CREATEDB); + } + break; + case 4: + { + setState(2520); + match(NOCREATEDB); + } + break; + case 5: + { + setState(2521); + match(CREATEROLE); + } + break; + case 6: + { + setState(2522); + match(NOCREATEROLE); + } + break; + case 7: + { + setState(2523); + match(CREATEUSER); + } + break; + case 8: + { + setState(2524); + match(NOCREATEUSER); + } + break; + case 9: + { + setState(2525); + match(INHERIT); + } + break; + case 10: + { + setState(2526); + match(NOINHERIT); + } + break; + case 11: + { + setState(2527); + match(LOGIN); + } + break; + case 12: + { + setState(2528); + match(NOLOGIN); + } + break; + case 13: + { + setState(2530); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENCRYPTED || _la==UNENCRYPTED) { + { + setState(2529); + _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(2532); + match(PASSWORD); + setState(2533); + _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(2534); + match(VALID); + setState(2535); + match(UNTIL); + setState(2536); + match(SINGLEQ_STRING_LITERAL); + } + break; + case 15: + { + setState(2537); + match(IN); + setState(2538); + match(ROLE); + setState(2539); + name_list(); + } + break; + case 16: + { + setState(2540); + match(IN); + setState(2541); + match(GROUP); + setState(2542); + name_list(); + } + break; + case 17: + { + setState(2543); + match(ROLE); + setState(2544); + name_list(); + } + break; + case 18: + { + setState(2545); + match(ADMIN); + setState(2546); + name_list(); + } + break; + case 19: + { + setState(2547); + match(USER); + setState(2548); + name_list(); + } + break; + case 20: + { + setState(2549); + match(SYSID); + setState(2550); + match(INTEGER_LITERAL); + } + break; + } + } + setState(2553); + _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)) & 144150372447944705L) != 0) || ((((_la - 628)) & ~0x3f) == 0 && ((1L << (_la - 628)) & 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(2557); + match(CREATE); + setState(2559); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==UNIQUE) { + { + setState(2558); + match(UNIQUE); + } + } + + setState(2561); + match(INDEX); + setState(2563); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONCURRENTLY) { + { + setState(2562); + match(CONCURRENTLY); + } + } + + setState(2571); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 4398046511191L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3170536334544601087L) != 0)) { + { + setState(2568); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(2565); + match(IF); + setState(2566); + match(NOT); + setState(2567); + match(EXISTS); + } + } + + setState(2570); + ((Create_index_stmtContext)_localctx).index_name = identifier(0); + } + } + + setState(2573); + match(ON); + setState(2574); + ((Create_index_stmtContext)_localctx).tableName = identifier(0); + setState(2577); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(2575); + match(USING); + setState(2576); + index_method(); + } + } + + setState(2581); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TABLESPACE) { + { + setState(2579); + match(TABLESPACE); + setState(2580); + ((Create_index_stmtContext)_localctx).tablespace_name = identifier(0); + } + } + + setState(2585); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2583); + match(WHERE); + setState(2584); + 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(2620); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,218,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + { + setState(2587); + match(CREATE); + setState(2590); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OR) { + { + setState(2588); + match(OR); + setState(2589); + match(REPLACE); + } + } + + setState(2593); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PROCEDURAL) { + { + setState(2592); + match(PROCEDURAL); + } + } + + setState(2595); + match(LANGUAGE); + setState(2596); + ((Create_language_stmtContext)_localctx).language_name = identifier(0); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + { + setState(2597); + match(CREATE); + setState(2600); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OR) { + { + setState(2598); + match(OR); + setState(2599); + match(REPLACE); + } + } + + setState(2603); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TRUSTED) { + { + setState(2602); + match(TRUSTED); + } + } + + setState(2606); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PROCEDURAL) { + { + setState(2605); + match(PROCEDURAL); + } + } + + setState(2608); + match(LANGUAGE); + setState(2609); + ((Create_language_stmtContext)_localctx).language_name = identifier(0); + setState(2610); + match(HANDLER); + setState(2611); + ((Create_language_stmtContext)_localctx).call_handler = identifier(0); + setState(2614); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INLINE) { + { + setState(2612); + match(INLINE); + setState(2613); + ((Create_language_stmtContext)_localctx).inline_handler = identifier(0); + } + } + + setState(2618); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VALIDATOR) { + { + setState(2616); + match(VALIDATOR); + setState(2617); + ((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(2622); + match(CREATE); + setState(2623); + match(MATERIALIZED); + setState(2624); + match(VIEW); + setState(2628); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(2625); + match(IF); + setState(2626); + match(NOT); + setState(2627); + match(EXISTS); + } + } + + setState(2630); + ((Create_materialized_view_stmtContext)_localctx).tableName = identifier(0); + setState(2635); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(2631); + match(OPEN_PAREN); + setState(2632); + ((Create_materialized_view_stmtContext)_localctx).columns = identifier_list(); + setState(2633); + match(CLOSE_PAREN); + } + } + + setState(2638); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2637); + match(WITH); + } + } + + setState(2642); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TABLESPACE) { + { + setState(2640); + match(TABLESPACE); + setState(2641); + ((Create_materialized_view_stmtContext)_localctx).tablespace_name = identifier(0); + } + } + + setState(2644); + match(AS); + setState(2645); + ((Create_materialized_view_stmtContext)_localctx).query = select_stmt(); + setState(2651); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2646); + match(WITH); + setState(2648); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(2647); + match(NO); + } + } + + setState(2650); + 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(2653); + match(CREATE); + setState(2654); + match(OPERATOR); + setState(2655); + ((Create_operator_stmtContext)_localctx).opName = identifier(0); + setState(2656); + match(OPEN_PAREN); + setState(2657); + match(PROCEDURE); + setState(2658); + match(EQUAL); + setState(2659); + ((Create_operator_stmtContext)_localctx).function_name = identifier(0); + setState(2664); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,225,_ctx) ) { + case 1: + { + setState(2660); + match(COMMA); + setState(2661); + match(LEFTARG); + setState(2662); + match(EQUAL); + setState(2663); + ((Create_operator_stmtContext)_localctx).left_type = name_(); + } + break; + } + setState(2670); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,226,_ctx) ) { + case 1: + { + setState(2666); + match(COMMA); + setState(2667); + match(RIGHTARG); + setState(2668); + match(EQUAL); + setState(2669); + ((Create_operator_stmtContext)_localctx).right_type = name_(); + } + break; + } + setState(2676); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,227,_ctx) ) { + case 1: + { + setState(2672); + match(COMMA); + setState(2673); + match(COMMUTATOR); + setState(2674); + match(EQUAL); + setState(2675); + ((Create_operator_stmtContext)_localctx).com_op = name_(); + } + break; + } + setState(2682); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) { + case 1: + { + setState(2678); + match(COMMA); + setState(2679); + match(NEGATOR); + setState(2680); + match(EQUAL); + setState(2681); + ((Create_operator_stmtContext)_localctx).neg_op = name_(); + } + break; + } + setState(2688); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) { + case 1: + { + setState(2684); + match(COMMA); + setState(2685); + match(RESTRICT); + setState(2686); + match(EQUAL); + setState(2687); + ((Create_operator_stmtContext)_localctx).res_proc = name_(); + } + break; + } + setState(2694); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,230,_ctx) ) { + case 1: + { + setState(2690); + match(COMMA); + setState(2691); + match(JOIN); + setState(2692); + match(EQUAL); + setState(2693); + ((Create_operator_stmtContext)_localctx).join_proc = name_(); + } + break; + } + setState(2698); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,231,_ctx) ) { + case 1: + { + setState(2696); + match(COMMA); + setState(2697); + match(HASHES); + } + break; + } + setState(2702); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2700); + match(COMMA); + setState(2701); + match(MERGES); + } + } + + setState(2704); + 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(2736); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPERATOR: + enterOuterAlt(_localctx, 1); + { + { + setState(2706); + match(OPERATOR); + setState(2707); + ((Create_operator_class_optContext)_localctx).strategy_number = match(INTEGER_LITERAL); + setState(2708); + ((Create_operator_class_optContext)_localctx).opName = identifier(0); + setState(2715); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(2709); + match(OPEN_PAREN); + setState(2710); + identifier(0); + setState(2711); + match(COMMA); + setState(2712); + identifier(0); + setState(2713); + match(CLOSE_PAREN); + } + } + + } + } + break; + case FUNCTION: + enterOuterAlt(_localctx, 2); + { + { + setState(2717); + match(FUNCTION); + setState(2718); + ((Create_operator_class_optContext)_localctx).support_number = match(INTEGER_LITERAL); + setState(2727); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(2719); + match(OPEN_PAREN); + setState(2720); + identifier(0); + setState(2723); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(2721); + match(COMMA); + setState(2722); + identifier(0); + } + } + + setState(2725); + match(CLOSE_PAREN); + } + } + + setState(2729); + ((Create_operator_class_optContext)_localctx).func_name_ = identifier(0); + setState(2730); + match(OPEN_PAREN); + setState(2731); + data_type_list(); + setState(2732); + match(CLOSE_PAREN); + } + } + break; + case STORAGE: + enterOuterAlt(_localctx, 3); + { + { + setState(2734); + match(STORAGE); + setState(2735); + ((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(2738); + match(CREATE); + setState(2739); + match(OPERATOR); + setState(2740); + match(CLASS); + setState(2741); + ((Create_operator_class_stmtContext)_localctx).name = identifier(0); + setState(2743); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(2742); + match(DEFAULT); + } + } + + setState(2745); + match(FOR); + setState(2746); + match(TYPE); + setState(2747); + ((Create_operator_class_stmtContext)_localctx).op_type = identifier(0); + setState(2748); + match(USING); + setState(2749); + index_method(); + setState(2752); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FAMILY) { + { + setState(2750); + match(FAMILY); + setState(2751); + ((Create_operator_class_stmtContext)_localctx).family_name = identifier(0); + } + } + + setState(2754); + match(AS); + setState(2755); + create_operator_class_opt(); + setState(2760); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(2756); + match(COMMA); + setState(2757); + create_operator_class_opt(); + } + } + setState(2762); + _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(2763); + match(CREATE); + setState(2764); + match(OPERATOR); + setState(2765); + match(FAMILY); + setState(2766); + ((Create_operator_family_stmtContext)_localctx).name = identifier(0); + setState(2767); + match(USING); + setState(2768); + 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(2770); + match(CREATE); + setState(2771); + match(POLICY); + setState(2772); + ((Create_policy_stmtContext)_localctx).name = identifier(0); + setState(2773); + match(ON); + setState(2774); + ((Create_policy_stmtContext)_localctx).tableName = identifier(0); + setState(2777); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(2775); + match(FOR); + setState(2776); + _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(2781); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TO) { + { + setState(2779); + match(TO); + setState(2780); + ((Create_policy_stmtContext)_localctx).role = role_name(); + } + } + + setState(2788); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(2783); + match(USING); + setState(2784); + match(OPEN_PAREN); + setState(2785); + predicate(0); + setState(2786); + match(CLOSE_PAREN); + } + } + + setState(2796); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2790); + match(WITH); + setState(2791); + match(CHECK); + setState(2792); + match(OPEN_PAREN); + setState(2793); + predicate(0); + setState(2794); + 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 INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } + public TerminalNode INTEGER_LITERAL(int i) { + return getToken(PostgreSqlParser.INTEGER_LITERAL, 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 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(2798); + match(CREATE); + setState(2799); + match(ROLE); + setState(2800); + ((Create_role_stmtContext)_localctx).role = role_name(); + setState(2847); + _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 - 628)) & ~0x3f) == 0 && ((1L << (_la - 628)) & 1099243716609L) != 0)) { + { + setState(2802); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2801); + match(WITH); + } + } + + setState(2843); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + setState(2843); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,246,_ctx) ) { + case 1: + { + setState(2804); + match(SUPERUSER); + } + break; + case 2: + { + setState(2805); + match(NOSUPERUSER); + } + break; + case 3: + { + setState(2806); + match(CREATEDB); + } + break; + case 4: + { + setState(2807); + match(NOCREATEDB); + } + break; + case 5: + { + setState(2808); + match(CREATEROLE); + } + break; + case 6: + { + setState(2809); + match(NOCREATEROLE); + } + break; + case 7: + { + setState(2810); + match(INHERIT); + } + break; + case 8: + { + setState(2811); + match(NOINHERIT); + } + break; + case 9: + { + setState(2812); + match(LOGIN); + } + break; + case 10: + { + setState(2813); + match(NOLOGIN); + } + break; + case 11: + { + setState(2814); + match(REPLICATION); + } + break; + case 12: + { + setState(2815); + match(NOREPLICATION); + } + break; + case 13: + { + setState(2816); + match(BYPASSRLS); + } + break; + case 14: + { + setState(2817); + match(NOBYPASSRLS); + } + break; + case 15: + { + setState(2818); + match(CONNECTION); + setState(2819); + match(LIMIT); + setState(2820); + match(INTEGER_LITERAL); + } + break; + case 16: + { + setState(2822); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ENCRYPTED) { + { + setState(2821); + match(ENCRYPTED); + } + } + + setState(2824); + match(PASSWORD); + setState(2825); + _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(2826); + match(VALID); + setState(2827); + match(UNTIL); + setState(2828); + match(SINGLEQ_STRING_LITERAL); + } + break; + case 18: + { + setState(2829); + match(IN); + setState(2830); + match(ROLE); + setState(2831); + name_list(); + } + break; + case 19: + { + setState(2832); + match(IN); + setState(2833); + match(GROUP); + setState(2834); + name_list(); + } + break; + case 20: + { + setState(2835); + match(ROLE); + setState(2836); + name_list(); + } + break; + case 21: + { + setState(2837); + match(ADMIN); + setState(2838); + name_list(); + } + break; + case 22: + { + setState(2839); + match(USER); + setState(2840); + name_list(); + } + break; + case 23: + { + setState(2841); + match(SYSID); + setState(2842); + match(INTEGER_LITERAL); + } + break; + } + } + setState(2845); + _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 - 628)) & ~0x3f) == 0 && ((1L << (_la - 628)) & 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(2849); + _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(2851); + match(CREATE); + setState(2854); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OR) { + { + setState(2852); + match(OR); + setState(2853); + match(REPLACE); + } + } + + setState(2856); + match(RULE); + setState(2857); + ((Create_rule_stmtContext)_localctx).name = name_(); + setState(2858); + match(AS); + setState(2859); + match(ON); + setState(2860); + ((Create_rule_stmtContext)_localctx).event = create_rule_event(); + setState(2861); + match(TO); + setState(2862); + ((Create_rule_stmtContext)_localctx).tableName = identifier(0); + setState(2865); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(2863); + match(WHERE); + setState(2864); + predicate(0); + } + } + + setState(2867); + match(DO); + setState(2869); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,251,_ctx) ) { + case 1: + { + setState(2868); + _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(2873); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) { + case 1: + { + setState(2871); + match(NOTHING); + } + break; + case 2: + { + setState(2872); + ((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(2909); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,257,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + { + setState(2875); + match(CREATE); + setState(2876); + match(SCHEMA); + setState(2877); + ((Create_schema_stmtContext)_localctx).schema_name = identifier(0); + setState(2880); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,253,_ctx) ) { + case 1: + { + setState(2878); + match(AUTHORIZATION); + setState(2879); + role_name(); + } + break; + } + setState(2883); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,254,_ctx) ) { + case 1: + { + setState(2882); + todo_fill_in(); + } + break; + } + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + { + setState(2885); + match(CREATE); + setState(2886); + match(SCHEMA); + setState(2887); + match(AUTHORIZATION); + setState(2888); + role_name(); + setState(2890); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,255,_ctx) ) { + case 1: + { + setState(2889); + todo_fill_in(); + } + break; + } + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + { + setState(2892); + match(CREATE); + setState(2893); + match(SCHEMA); + setState(2894); + match(IF); + setState(2895); + match(NOT); + setState(2896); + match(EXISTS); + setState(2897); + ((Create_schema_stmtContext)_localctx).schema_name = identifier(0); + setState(2900); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AUTHORIZATION) { + { + setState(2898); + match(AUTHORIZATION); + setState(2899); + role_name(); + } + } + + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + { + setState(2902); + match(CREATE); + setState(2903); + match(SCHEMA); + setState(2904); + match(IF); + setState(2905); + match(NOT); + setState(2906); + match(EXISTS); + setState(2907); + match(AUTHORIZATION); + setState(2908); + 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 Token increment; + public Token minvalue; + public Token maxvalue; + public Token start; + public Token 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 INTEGER_LITERAL() { return getTokens(PostgreSqlParser.INTEGER_LITERAL); } + public TerminalNode INTEGER_LITERAL(int i) { + return getToken(PostgreSqlParser.INTEGER_LITERAL, 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(2911); + match(CREATE); + setState(2913); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TEMP || _la==TEMPORARY) { + { + setState(2912); + _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(2915); + match(SEQUENCE); + setState(2919); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(2916); + match(IF); + setState(2917); + match(NOT); + setState(2918); + match(EXISTS); + } + } + + setState(2921); + ((Create_sequence_stmtContext)_localctx).name = identifier(0); + setState(2927); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INCREMENT) { + { + setState(2922); + match(INCREMENT); + setState(2924); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==BY) { + { + setState(2923); + match(BY); + } + } + + setState(2926); + ((Create_sequence_stmtContext)_localctx).increment = match(INTEGER_LITERAL); + } + } + + setState(2933); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,262,_ctx) ) { + case 1: + { + setState(2929); + match(MINVALUE); + setState(2930); + ((Create_sequence_stmtContext)_localctx).minvalue = match(INTEGER_LITERAL); + } + break; + case 2: + { + setState(2931); + match(NO); + setState(2932); + match(MINVALUE); + } + break; + } + setState(2939); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) { + case 1: + { + setState(2935); + match(MAXVALUE); + setState(2936); + ((Create_sequence_stmtContext)_localctx).maxvalue = match(INTEGER_LITERAL); + } + break; + case 2: + { + setState(2937); + match(NO); + setState(2938); + match(MAXVALUE); + } + break; + } + setState(2946); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==START) { + { + setState(2941); + match(START); + setState(2943); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(2942); + match(WITH); + } + } + + setState(2945); + ((Create_sequence_stmtContext)_localctx).start = match(INTEGER_LITERAL); + } + } + + setState(2950); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CACHE) { + { + setState(2948); + match(CACHE); + setState(2949); + ((Create_sequence_stmtContext)_localctx).cache = match(INTEGER_LITERAL); + } + } + + setState(2956); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CYCLE || _la==NO) { + { + setState(2953); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(2952); + match(NO); + } + } + + setState(2955); + match(CYCLE); + } + } + + setState(2967); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OWNED) { + { + setState(2958); + match(OWNED); + setState(2959); + match(BY); + setState(2965); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,269,_ctx) ) { + case 1: + { + { + setState(2960); + ((Create_sequence_stmtContext)_localctx).table_name = identifier(0); + setState(2961); + match(DOT); + setState(2962); + ((Create_sequence_stmtContext)_localctx).column_name_ = identifier(0); + } + } + break; + case 2: + { + setState(2964); + 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(2969); + 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(2971); + 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(2973); + 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(2975); + 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(2977); + 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(2979); + 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(2981); + 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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(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_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(2999); + match(CREATE); + setState(3002); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OR) { + { + setState(3000); + match(OR); + setState(3001); + match(REPLACE); + } + } + + setState(3005); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TEMP || _la==TEMPORARY) { + { + setState(3004); + _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(3008); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RECURSIVE) { + { + setState(3007); + match(RECURSIVE); + } + } + + setState(3010); + match(VIEW); + setState(3011); + ((Create_view_stmtContext)_localctx).name = name_(); + setState(3016); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(3012); + match(OPEN_PAREN); + setState(3013); + name_list(); + setState(3014); + match(CLOSE_PAREN); + } + } + + setState(3023); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(3018); + match(WITH); + setState(3019); + match(OPEN_PAREN); + setState(3020); + option_list(); + setState(3021); + match(CLOSE_PAREN); + } + } + + setState(3025); + match(AS); + setState(3028); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,276,_ctx) ) { + case 1: + { + setState(3026); + select_stmt(); + } + break; + case 2: + { + setState(3027); + values_stmt(); + } + break; + } + setState(3036); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(3030); + match(WITH); + setState(3032); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADED || _la==LOCAL) { + { + setState(3031); + _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(3034); + match(CHECK); + setState(3035); + 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(3038); + 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(3040); + 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(3043); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(3042); + with_clause(); + } + } + + setState(3045); + match(DELETE); + setState(3046); + match(FROM); + setState(3048); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(3047); + match(ONLY); + } + } + + setState(3050); + table_name_(); + setState(3052); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STAR) { + { + setState(3051); + match(STAR); + } + } + + setState(3058); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3170536334544601087L) != 0)) { + { + setState(3055); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3054); + match(AS); + } + } + + setState(3057); + alias(); + } + } + + setState(3062); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(3060); + match(USING); + setState(3061); + identifier_list(); + } + } + + setState(3069); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) { + case 1: + { + setState(3064); + where_clause(); + } + break; + case 2: + { + { + setState(3065); + match(WHERE); + setState(3066); + match(CURRENT); + setState(3067); + match(OF); + setState(3068); + ((Delete_stmtContext)_localctx).cursor_name_ = identifier(0); + } + } + break; + } + setState(3072); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RETURNING) { + { + setState(3071); + 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(3074); + match(DISCARD); + setState(3075); + _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(3118); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,287,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3077); + drop_access_method_stmt(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3078); + drop_aggregate_stmt(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3079); + drop_cast_stmt(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(3080); + drop_collation_stmt(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(3081); + drop_conversion_stmt(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(3082); + drop_database_stmt(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(3083); + drop_domain_stmt(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(3084); + drop_event_trigger_stmt(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(3085); + drop_extension_stmt(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(3086); + drop_foreign_data_wrapper_stmt(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(3087); + drop_foreign_table_stmt(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(3088); + drop_function_stmt(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(3089); + drop_group_stmt(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(3090); + drop_index_stmt(); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(3091); + drop_language_stmt(); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(3092); + drop_materialized_view_stmt(); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(3093); + drop_operator_stmt(); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(3094); + drop_operator_class_stmt(); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(3095); + drop_operator_family_stmt(); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(3096); + drop_owned_stmt(); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(3097); + drop_policy_stmt(); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(3098); + drop_publication_stmt(); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(3099); + drop_role_stmt(); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(3100); + drop_rule_stmt(); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(3101); + drop_schema_stmt(); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(3102); + drop_sequence_stmt(); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(3103); + drop_server_stmt(); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(3104); + drop_statistics_stmt(); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(3105); + drop_subscription_stmt(); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(3106); + drop_table_stmt(); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(3107); + drop_tablespace_stmt(); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(3108); + drop_text_search_config_stmt(); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(3109); + drop_text_search_dict_stmt(); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(3110); + drop_text_search_parser_stmt(); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(3111); + drop_text_search_template_stmt(); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(3112); + drop_transform_stmt(); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(3113); + drop_trigger_stmt(); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(3114); + drop_type_stmt(); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(3115); + drop_user_stmt(); + } + break; + case 40: + enterOuterAlt(_localctx, 40); + { + setState(3116); + drop_user_mapping_stmt(); + } + break; + case 41: + enterOuterAlt(_localctx, 41); + { + setState(3117); + drop_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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_drop_access_method_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_access_method_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_access_method_stmt(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); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3120); + match(DROP); + setState(3121); + match(ACCESS); + setState(3122); + match(METHOD); + setState(3125); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3123); + match(IF); + setState(3124); + match(EXISTS); + } + } + + setState(3127); + ((Drop_access_method_stmtContext)_localctx).name = identifier(0); + setState(3129); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3128); + _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_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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_drop_aggregate_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_aggregate_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_aggregate_stmt(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; + try { + enterOuterAlt(_localctx, 1); + { + setState(3131); + match(DROP); + setState(3132); + match(AGGREGATE); + setState(3135); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3133); + match(IF); + setState(3134); + match(EXISTS); + } + } + + setState(3137); + ((Drop_aggregate_stmtContext)_localctx).name = identifier(0); + setState(3138); + match(OPEN_PAREN); + setState(3139); + aggregate_signature(); + setState(3140); + 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 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(3142); + match(DROP); + setState(3143); + match(CAST); + setState(3146); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3144); + match(IF); + setState(3145); + match(EXISTS); + } + } + + setState(3148); + match(OPEN_PAREN); + setState(3149); + ((Drop_cast_stmtContext)_localctx).source_type = data_type(); + setState(3150); + match(AS); + setState(3151); + ((Drop_cast_stmtContext)_localctx).target_type = identifier(0); + setState(3152); + match(CLOSE_PAREN); + setState(3154); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3153); + _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(3156); + match(DROP); + setState(3157); + match(COLLATION); + setState(3160); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3158); + match(IF); + setState(3159); + match(EXISTS); + } + } + + setState(3162); + ((Drop_collation_stmtContext)_localctx).names = identifier_list(); + setState(3164); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3163); + _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(3166); + match(DROP); + setState(3167); + match(CONVERSION); + setState(3170); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3168); + match(IF); + setState(3169); + match(EXISTS); + } + } + + setState(3172); + ((Drop_conversion_stmtContext)_localctx).name = identifier(0); + setState(3174); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3173); + _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(3176); + match(DROP); + setState(3177); + match(DATABASE); + setState(3180); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3178); + match(IF); + setState(3179); + match(EXISTS); + } + } + + setState(3182); + ((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(3184); + match(DROP); + setState(3185); + match(DOMAIN); + setState(3188); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3186); + match(IF); + setState(3187); + match(EXISTS); + } + } + + setState(3190); + ((Drop_domain_stmtContext)_localctx).names = identifier_list(); + setState(3192); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3191); + _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(3194); + match(DROP); + setState(3195); + match(EVENT); + setState(3196); + match(TRIGGER); + setState(3199); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3197); + match(IF); + setState(3198); + match(EXISTS); + } + } + + setState(3201); + ((Drop_event_trigger_stmtContext)_localctx).name = identifier(0); + setState(3203); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3202); + _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(3205); + match(DROP); + setState(3206); + match(EXTENSION); + setState(3209); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3207); + match(IF); + setState(3208); + match(EXISTS); + } + } + + setState(3211); + ((Drop_extension_stmtContext)_localctx).names = identifier_list(); + setState(3213); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3212); + _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(3215); + match(DROP); + setState(3216); + match(FOREIGN); + setState(3217); + match(DATA); + setState(3218); + match(WRAPPER); + setState(3221); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3219); + match(IF); + setState(3220); + match(EXISTS); + } + } + + setState(3223); + ((Drop_foreign_data_wrapper_stmtContext)_localctx).names = identifier_list(); + setState(3225); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3224); + _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(3227); + match(DROP); + setState(3228); + match(FOREIGN); + setState(3229); + match(TABLE); + setState(3232); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3230); + match(IF); + setState(3231); + match(EXISTS); + } + } + + setState(3234); + ((Drop_foreign_table_stmtContext)_localctx).names = identifier_list(); + setState(3236); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3235); + _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(3238); + match(DROP); + setState(3239); + match(FUNCTION); + setState(3242); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3240); + match(IF); + setState(3241); + match(EXISTS); + } + } + + setState(3244); + ((Drop_function_stmtContext)_localctx).functions = func_sig_list(); + setState(3246); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3245); + _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(3248); + match(DROP); + setState(3249); + match(GROUP); + setState(3252); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3250); + match(IF); + setState(3251); + match(EXISTS); + } + } + + setState(3254); + ((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(3256); + match(DROP); + setState(3257); + match(INDEX); + setState(3259); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONCURRENTLY) { + { + setState(3258); + match(CONCURRENTLY); + } + } + + setState(3263); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3261); + match(IF); + setState(3262); + match(EXISTS); + } + } + + setState(3265); + ((Drop_index_stmtContext)_localctx).names = name_list(); + setState(3267); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3266); + _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(3269); + match(DROP); + setState(3271); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PROCEDURAL) { + { + setState(3270); + match(PROCEDURAL); + } + } + + setState(3273); + match(LANGUAGE); + setState(3276); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3274); + match(IF); + setState(3275); + match(EXISTS); + } + } + + setState(3278); + ((Drop_language_stmtContext)_localctx).name = identifier(0); + setState(3280); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3279); + _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(3282); + match(DROP); + setState(3283); + match(MATERIALIZED); + setState(3284); + match(VIEW); + setState(3287); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3285); + match(IF); + setState(3286); + match(EXISTS); + } + } + + setState(3289); + ((Drop_materialized_view_stmtContext)_localctx).names = identifier_list(); + setState(3291); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3290); + _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(3293); + 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(3295); + match(DROP); + setState(3296); + match(OPERATOR); + setState(3297); + match(CLASS); + setState(3300); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3298); + match(IF); + setState(3299); + match(EXISTS); + } + } + + setState(3302); + ((Drop_operator_class_stmtContext)_localctx).name = identifier(0); + setState(3303); + match(USING); + setState(3304); + index_method(); + setState(3306); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3305); + _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(3308); + match(DROP); + setState(3309); + match(OPERATOR); + setState(3310); + match(FAMILY); + setState(3313); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3311); + match(IF); + setState(3312); + match(EXISTS); + } + } + + setState(3315); + ((Drop_operator_family_stmtContext)_localctx).name = identifier(0); + setState(3316); + match(USING); + setState(3317); + index_method(); + setState(3319); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3318); + _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(3321); + match(DROP); + setState(3322); + match(OWNED); + setState(3323); + match(BY); + setState(3324); + role_name_list(); + setState(3326); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3325); + _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(3328); + match(DROP); + setState(3329); + match(POLICY); + setState(3332); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3330); + match(IF); + setState(3331); + match(EXISTS); + } + } + + setState(3334); + ((Drop_policy_stmtContext)_localctx).name = identifier(0); + setState(3335); + match(ON); + setState(3336); + ((Drop_policy_stmtContext)_localctx).table_name = identifier(0); + setState(3338); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3337); + _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(3340); + match(DROP); + setState(3341); + match(PUBLICATION); + setState(3344); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3342); + match(IF); + setState(3343); + match(EXISTS); + } + } + + setState(3346); + ((Drop_publication_stmtContext)_localctx).names = identifier_list(); + setState(3348); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3347); + _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 TerminalNode ROLE() { return getToken(PostgreSqlParser.ROLE, 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_role_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_drop_role_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterDrop_role_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitDrop_role_stmt(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; + try { + enterOuterAlt(_localctx, 1); + { + setState(3350); + match(DROP); + setState(3351); + match(ROLE); + setState(3354); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3352); + match(IF); + setState(3353); + match(EXISTS); + } + } + + setState(3356); + ((Drop_role_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_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(3358); + match(DROP); + setState(3359); + match(RULE); + setState(3362); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3360); + match(IF); + setState(3361); + match(EXISTS); + } + } + + setState(3364); + ((Drop_rule_stmtContext)_localctx).name = name_(); + setState(3365); + match(ON); + setState(3366); + ((Drop_rule_stmtContext)_localctx).table_name = identifier(0); + setState(3368); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3367); + _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(3370); + match(DROP); + setState(3371); + match(SCHEMA); + setState(3374); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3372); + match(IF); + setState(3373); + match(EXISTS); + } + } + + setState(3376); + ((Drop_schema_stmtContext)_localctx).names = identifier_list(); + setState(3378); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3377); + _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(3380); + match(DROP); + setState(3381); + match(SEQUENCE); + setState(3384); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3382); + match(IF); + setState(3383); + match(EXISTS); + } + } + + setState(3386); + ((Drop_sequence_stmtContext)_localctx).names = identifier_list(); + setState(3388); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3387); + _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(3390); + match(DROP); + setState(3391); + match(SERVER); + setState(3394); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3392); + match(IF); + setState(3393); + match(EXISTS); + } + } + + setState(3396); + ((Drop_server_stmtContext)_localctx).names = identifier_list(); + setState(3398); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3397); + _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(3400); + match(DROP); + setState(3401); + match(STATISTICS); + setState(3404); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3402); + match(IF); + setState(3403); + match(EXISTS); + } + } + + setState(3406); + ((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(3408); + match(DROP); + setState(3409); + match(SUBSCRIPTION); + setState(3412); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3410); + match(IF); + setState(3411); + match(EXISTS); + } + } + + setState(3414); + ((Drop_subscription_stmtContext)_localctx).name = identifier(0); + setState(3416); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3415); + _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(3418); + match(DROP); + setState(3419); + match(TABLE); + setState(3422); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3420); + match(IF); + setState(3421); + match(EXISTS); + } + } + + setState(3424); + ((Drop_table_stmtContext)_localctx).names = identifier_list(); + setState(3426); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3425); + _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(3428); + match(DROP); + setState(3429); + match(TABLESPACE); + setState(3432); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3430); + match(IF); + setState(3431); + match(EXISTS); + } + } + + setState(3434); + ((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(3436); + match(DROP); + setState(3437); + match(TEXT); + setState(3438); + match(SEARCH); + setState(3439); + match(CONFIGURATION); + setState(3442); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3440); + match(IF); + setState(3441); + match(EXISTS); + } + } + + setState(3444); + ((Drop_text_search_config_stmtContext)_localctx).name = identifier(0); + setState(3446); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3445); + _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(3448); + match(DROP); + setState(3449); + match(TEXT); + setState(3450); + match(SEARCH); + setState(3451); + match(DICTIONARY); + setState(3454); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3452); + match(IF); + setState(3453); + match(EXISTS); + } + } + + setState(3456); + ((Drop_text_search_dict_stmtContext)_localctx).name = identifier(0); + setState(3458); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3457); + _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(3460); + match(DROP); + setState(3461); + match(TEXT); + setState(3462); + match(SEARCH); + setState(3463); + match(PARSER); + setState(3466); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3464); + match(IF); + setState(3465); + match(EXISTS); + } + } + + setState(3468); + ((Drop_text_search_parser_stmtContext)_localctx).name = identifier(0); + setState(3470); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3469); + _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(3472); + match(DROP); + setState(3473); + match(TEXT); + setState(3474); + match(SEARCH); + setState(3475); + match(TEMPLATE); + setState(3478); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3476); + match(IF); + setState(3477); + match(EXISTS); + } + } + + setState(3480); + ((Drop_text_search_template_stmtContext)_localctx).name = identifier(0); + setState(3482); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3481); + _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(3484); + match(DROP); + setState(3485); + match(TRANSFORM); + setState(3488); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3486); + match(IF); + setState(3487); + match(EXISTS); + } + } + + setState(3490); + match(FOR); + setState(3491); + ((Drop_transform_stmtContext)_localctx).type_name_ = identifier(0); + setState(3492); + match(LANGUAGE); + setState(3493); + ((Drop_transform_stmtContext)_localctx).lang_name = identifier(0); + setState(3494); + _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(3496); + match(DROP); + setState(3497); + match(TRIGGER); + setState(3500); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3498); + match(IF); + setState(3499); + match(EXISTS); + } + } + + setState(3502); + ((Drop_trigger_stmtContext)_localctx).name = identifier(0); + setState(3503); + match(ON); + setState(3504); + ((Drop_trigger_stmtContext)_localctx).table_name = identifier(0); + setState(3506); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3505); + _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(3508); + match(DROP); + setState(3509); + match(TYPE); + setState(3512); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3510); + match(IF); + setState(3511); + match(EXISTS); + } + } + + setState(3514); + ((Drop_type_stmtContext)_localctx).names = identifier_list(); + setState(3516); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3515); + _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(3518); + match(DROP); + setState(3519); + match(USER); + setState(3522); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3520); + match(IF); + setState(3521); + match(EXISTS); + } + } + + setState(3524); + ((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(3526); + match(DROP); + setState(3527); + match(USER); + setState(3528); + match(MAPPING); + setState(3531); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3529); + match(IF); + setState(3530); + match(EXISTS); + } + } + + setState(3533); + match(FOR); + setState(3539); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,358,_ctx) ) { + case 1: + { + setState(3534); + ((Drop_user_mapping_stmtContext)_localctx).user_name = name_(); + } + break; + case 2: + { + setState(3535); + match(USER); + } + break; + case 3: + { + setState(3536); + match(CURRENT_USER); + } + break; + case 4: + { + setState(3537); + match(SESSION_USER); + } + break; + case 5: + { + setState(3538); + match(PUBLIC); + } + break; + } + setState(3541); + match(SERVER); + setState(3542); + ((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(3544); + match(DROP); + setState(3545); + match(VIEW); + setState(3548); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(3546); + match(IF); + setState(3547); + match(EXISTS); + } + } + + setState(3550); + ((Drop_view_stmtContext)_localctx).names = identifier_list(); + setState(3552); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(3551); + _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(3554); + match(EXECUTE); + setState(3555); + ((Execute_stmtContext)_localctx).name = identifier(0); + setState(3557); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(3556); + 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(3578); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,365,_ctx) ) { + case 1: + { + { + setState(3559); + match(EXPLAIN); + setState(3561); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ANALYZE) { + { + setState(3560); + match(ANALYZE); + } + } + + setState(3564); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VERBOSE) { + { + setState(3563); + match(VERBOSE); + } + } + + } + } + break; + case 2: + { + { + setState(3566); + match(EXPLAIN); + setState(3567); + match(OPEN_PAREN); + setState(3568); + explain_parameter(); + setState(3573); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3569); + match(COMMA); + setState(3570); + explain_parameter(); + } + } + setState(3575); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3576); + match(CLOSE_PAREN); + } + } + break; + } + setState(3589); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,366,_ctx) ) { + case 1: + { + setState(3580); + select_stmt(); + } + break; + case 2: + { + setState(3581); + insert_stmt(); + } + break; + case 3: + { + setState(3582); + update_stmt(); + } + break; + case 4: + { + setState(3583); + delete_stmt(); + } + break; + case 5: + { + setState(3584); + values_stmt(); + } + break; + case 6: + { + setState(3585); + execute_stmt(); + } + break; + case 7: + { + setState(3586); + declare_stmt(); + } + break; + case 8: + { + setState(3587); + create_table_as_stmt(); + } + break; + case 9: + { + setState(3588); + 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(3591); + 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(3593); + 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(3595); + 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(3598); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(3597); + with_clause(); + } + } + + setState(3600); + match(INSERT); + setState(3601); + match(INTO); + setState(3602); + table_name_(); + setState(3605); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(3603); + match(AS); + setState(3604); + ((Insert_stmtContext)_localctx).alias_ = identifier(0); + } + } + + setState(3611); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,369,_ctx) ) { + case 1: + { + setState(3607); + match(OPEN_PAREN); + setState(3608); + name_list(); + setState(3609); + match(CLOSE_PAREN); + } + break; + } + setState(3618); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OVERRIDING) { + { + setState(3613); + match(OVERRIDING); + setState(3615); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SYSTEM || _la==USER) { + { + setState(3614); + _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(3617); + match(VALUE); + } + } + + setState(3624); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,372,_ctx) ) { + case 1: + { + setState(3620); + match(DEFAULT); + setState(3621); + match(VALUES); + } + break; + case 2: + { + setState(3622); + select_stmt(); + } + break; + case 3: + { + setState(3623); + values_stmt(); + } + break; + } + setState(3653); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(3626); + match(ON); + setState(3627); + match(CONFLICT); + setState(3632); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(3628); + match(OPEN_PAREN); + setState(3629); + column_name(); + setState(3630); + match(CLOSE_PAREN); + } + } + + setState(3637); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(3634); + match(ON); + setState(3635); + match(CONSTRAINT); + setState(3636); + column_name(); + } + } + + setState(3640); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3639); + where_clause(); + } + } + + setState(3651); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,377,_ctx) ) { + case 1: + { + { + setState(3642); + match(DO); + setState(3643); + match(NOTHING); + } + } + break; + case 2: + { + { + setState(3644); + match(DO); + setState(3645); + match(UPDATE); + setState(3646); + match(SET); + setState(3647); + updater_clause(); + setState(3649); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3648); + where_clause(); + } + } + + } + } + break; + } + } + } + + setState(3656); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RETURNING) { + { + setState(3655); + 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(3658); + match(LISTEN); + setState(3659); + ((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(3661); + 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(3663); + match(LOCK); + setState(3665); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TABLE) { + { + setState(3664); + match(TABLE); + } + } + + setState(3668); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(3667); + match(ONLY); + } + } + + setState(3670); + ((Lock_stmtContext)_localctx).name = name_(); + setState(3672); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STAR) { + { + setState(3671); + match(STAR); + } + } + + setState(3694); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN) { + { + setState(3674); + match(IN); + setState(3691); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,383,_ctx) ) { + case 1: + { + setState(3675); + match(ACCESS); + setState(3676); + match(SHARE); + } + break; + case 2: + { + setState(3677); + match(ROW); + setState(3678); + match(SHARE); + } + break; + case 3: + { + setState(3679); + match(ROW); + setState(3680); + match(EXCLUSIVE); + } + break; + case 4: + { + setState(3681); + match(SHARE); + setState(3682); + match(UPDATE); + setState(3683); + match(EXCLUSIVE); + } + break; + case 5: + { + setState(3684); + match(SHARE); + } + break; + case 6: + { + setState(3685); + match(SHARE); + setState(3686); + match(ROW); + setState(3687); + match(EXCLUSIVE); + } + break; + case 7: + { + setState(3688); + match(EXCLUSIVE); + } + break; + case 8: + { + setState(3689); + match(ACCESS); + setState(3690); + match(EXCLUSIVE); + } + break; + } + setState(3693); + match(MODE); + } + } + + setState(3697); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOWAIT) { + { + setState(3696); + 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 TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 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(3699); + match(MOVE); + setState(3723); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,390,_ctx) ) { + case 1: + { + setState(3718); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NEXT: + { + setState(3700); + match(NEXT); + } + break; + case PRIOR: + { + setState(3701); + match(PRIOR); + } + break; + case FIRST: + { + setState(3702); + match(FIRST); + } + break; + case LAST: + { + setState(3703); + match(LAST); + } + break; + case ABSOLUTE: + { + setState(3704); + match(ABSOLUTE); + setState(3705); + match(INTEGER); + } + break; + case RELATIVE: + { + setState(3706); + match(RELATIVE); + setState(3707); + match(INTEGER_LITERAL); + } + break; + case INTEGER_LITERAL: + { + setState(3708); + match(INTEGER_LITERAL); + } + break; + case ALL: + { + setState(3709); + match(ALL); + } + break; + case FORWARD: + { + setState(3710); + match(FORWARD); + setState(3712); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL || _la==INTEGER_LITERAL) { + { + setState(3711); + _la = _input.LA(1); + if ( !(_la==ALL || _la==INTEGER_LITERAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + break; + case BACKWARD: + { + setState(3714); + match(BACKWARD); + setState(3716); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL || _la==INTEGER_LITERAL) { + { + setState(3715); + _la = _input.LA(1); + if ( !(_la==ALL || _la==INTEGER_LITERAL) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + setState(3721); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM || _la==IN) { + { + setState(3720); + _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(3725); + ((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(3727); + match(NOTIFY); + setState(3728); + ((Notify_stmtContext)_localctx).channel = name_(); + setState(3731); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(3729); + match(COMMA); + setState(3730); + ((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(3733); + match(PREPARE); + setState(3734); + ((Prepare_stmtContext)_localctx).name = identifier(0); + setState(3739); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(3735); + match(OPEN_PAREN); + setState(3736); + data_type_list(); + setState(3737); + match(CLOSE_PAREN); + } + } + + setState(3741); + match(AS); + setState(3747); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,393,_ctx) ) { + case 1: + { + setState(3742); + select_stmt(); + } + break; + case 2: + { + setState(3743); + insert_stmt(); + } + break; + case 3: + { + setState(3744); + update_stmt(); + } + break; + case 4: + { + setState(3745); + delete_stmt(); + } + break; + case 5: + { + setState(3746); + 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(3749); + match(PREPARE); + setState(3750); + match(TRANSACTION); + setState(3751); + ((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(3753); + match(REASSIGN); + setState(3754); + match(OWNED); + setState(3755); + match(BY); + { + setState(3759); + _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_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 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(3756); + identifier(0); + } + break; + case CURRENT_USER: + { + setState(3757); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(3758); + match(SESSION_USER); + } + break; + default: + throw new NoViableAltException(this); + } + setState(3769); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(3761); + match(COMMA); + setState(3765); + _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_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 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(3762); + identifier(0); + } + break; + case CURRENT_USER: + { + setState(3763); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(3764); + match(SESSION_USER); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(3771); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + setState(3772); + match(TO); + setState(3776); + _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_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 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(3773); + identifier(0); + } + break; + case CURRENT_USER: + { + setState(3774); + match(CURRENT_USER); + } + break; + case SESSION_USER: + { + setState(3775); + 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(3778); + 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(3780); + match(REINDEX); + setState(3784); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(3781); + match(OPEN_PAREN); + setState(3782); + match(VERBOSE); + setState(3783); + match(CLOSE_PAREN); + } + } + + setState(3786); + _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(3787); + ((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(3789); + match(RELEASE); + setState(3791); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,399,_ctx) ) { + case 1: + { + setState(3790); + match(SAVEPOINT); + } + break; + } + setState(3793); + ((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(3795); + match(RESET); + setState(3798); + _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_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 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(3796); + ((Reset_stmtContext)_localctx).configuration_parameter = identifier(0); + } + break; + case ALL: + { + setState(3797); + 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(3800); + 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(3802); + match(ROLLBACK); + setState(3804); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TRANSACTION || _la==WORK) { + { + setState(3803); + _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(3806); + match(ROLLBACK); + setState(3807); + match(PREPARED); + setState(3808); + ((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(3810); + match(ROLLBACK); + setState(3812); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TRANSACTION || _la==WORK) { + { + setState(3811); + _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(3814); + match(TO); + setState(3816); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,403,_ctx) ) { + case 1: + { + setState(3815); + match(SAVEPOINT); + } + break; + } + setState(3818); + ((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(3820); + match(SAVEPOINT); + setState(3821); + ((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(3823); + match(SECURITY); + setState(3824); + match(LABEL); + setState(3827); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(3825); + match(FOR); + setState(3826); + ((Security_label_stmtContext)_localctx).provider = name_(); + } + } + + setState(3829); + match(ON); + setState(3884); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TABLE: + { + setState(3830); + match(TABLE); + setState(3831); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case COLUMN: + { + setState(3832); + match(COLUMN); + setState(3833); + ((Security_label_stmtContext)_localctx).table_name = identifier(0); + setState(3834); + match(DOT); + setState(3835); + ((Security_label_stmtContext)_localctx).column_name_ = column_name(); + } + break; + case AGGREGATE: + { + setState(3837); + match(AGGREGATE); + setState(3838); + ((Security_label_stmtContext)_localctx).aggregate_name = identifier(0); + setState(3839); + match(OPEN_PAREN); + setState(3840); + aggregate_signature(); + setState(3841); + match(CLOSE_PAREN); + } + break; + case DATABASE: + { + setState(3843); + match(DATABASE); + setState(3844); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case DOMAIN: + { + setState(3845); + match(DOMAIN); + setState(3846); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case EVENT: + { + setState(3847); + match(EVENT); + setState(3848); + match(TRIGGER); + setState(3849); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case FOREIGN: + { + setState(3850); + match(FOREIGN); + setState(3851); + match(TABLE); + setState(3852); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case FUNCTION: + { + setState(3853); + match(FUNCTION); + setState(3854); + ((Security_label_stmtContext)_localctx).function_name = identifier(0); + setState(3855); + func_sig(); + } + break; + case LARGE: + { + setState(3857); + match(LARGE); + setState(3858); + match(OBJECT); + setState(3859); + ((Security_label_stmtContext)_localctx).large_object_oid = match(INTEGER_LITERAL); + } + break; + case MATERIALIZED: + { + setState(3860); + match(MATERIALIZED); + setState(3861); + match(VIEW); + setState(3862); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case LANGUAGE: + case PROCEDURAL: + { + setState(3864); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==PROCEDURAL) { + { + setState(3863); + match(PROCEDURAL); + } + } + + setState(3866); + match(LANGUAGE); + setState(3867); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case PUBLICATION: + { + setState(3868); + match(PUBLICATION); + setState(3869); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case ROLE: + { + setState(3870); + match(ROLE); + setState(3871); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case SCHEMA: + { + setState(3872); + match(SCHEMA); + setState(3873); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case SEQUENCE: + { + setState(3874); + match(SEQUENCE); + setState(3875); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case SUBSCRIPTION: + { + setState(3876); + match(SUBSCRIPTION); + setState(3877); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case TABLESPACE: + { + setState(3878); + match(TABLESPACE); + setState(3879); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case TYPE: + { + setState(3880); + match(TYPE); + setState(3881); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + case VIEW: + { + setState(3882); + match(VIEW); + setState(3883); + ((Security_label_stmtContext)_localctx).object_name = identifier(0); + } + break; + default: + throw new NoViableAltException(this); + } + setState(3886); + match(IS); + setState(3887); + ((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(3890); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(3889); + with_clause(); + } + } + + setState(3918); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + { + { + setState(3892); + match(SELECT); + setState(3893); + selector_clause(); + setState(3895); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,408,_ctx) ) { + case 1: + { + setState(3894); + from_clause(); + } + break; + } + } + } + break; + case TABLE: + { + { + setState(3897); + match(TABLE); + setState(3899); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(3898); + match(ONLY); + } + } + + setState(3901); + table_name_(); + setState(3903); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,410,_ctx) ) { + case 1: + { + setState(3902); + match(STAR); + } + break; + } + } + } + break; + case OPEN_PAREN: + { + { + setState(3906); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3905); + match(OPEN_PAREN); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3908); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,411,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(3910); + select_stmt(); + setState(3912); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3911); + match(CLOSE_PAREN); + } + } + setState(3914); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==CLOSE_PAREN ); + setState(3916); + combine_clause(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3921); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,414,_ctx) ) { + case 1: + { + setState(3920); + where_clause(); + } + break; + } + setState(3924); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,415,_ctx) ) { + case 1: + { + setState(3923); + group_by_clause(); + } + break; + } + setState(3927); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,416,_ctx) ) { + case 1: + { + setState(3926); + having_clause(); + } + break; + } + setState(3930); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,417,_ctx) ) { + case 1: + { + setState(3929); + window_clause(); + } + break; + } + setState(3933); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,418,_ctx) ) { + case 1: + { + setState(3932); + combine_clause(); + } + break; + } + setState(3936); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,419,_ctx) ) { + case 1: + { + setState(3935); + order_by_clause(); + } + break; + } + setState(3939); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,420,_ctx) ) { + case 1: + { + setState(3938); + limit_clause(); + } + break; + } + setState(3942); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,421,_ctx) ) { + case 1: + { + setState(3941); + offset_clause(); + } + break; + } + setState(3945); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,422,_ctx) ) { + case 1: + { + setState(3944); + fetch_clause(); + } + break; + } + setState(3948); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,423,_ctx) ) { + case 1: + { + setState(3947); + 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(3951); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(3950); + with_clause(); + } + } + + setState(3987); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SELECT: + { + { + setState(3953); + match(SELECT); + setState(3954); + selector_clause(); + setState(3955); + match(INTO); + setState(3957); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,425,_ctx) ) { + case 1: + { + setState(3956); + _la = _input.LA(1); + if ( !(((((_la - 571)) & ~0x3f) == 0 && ((1L << (_la - 571)) & 8796093022213L) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + setState(3960); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TABLE) { + { + setState(3959); + match(TABLE); + } + } + + setState(3962); + ((Select_into_stmtContext)_localctx).new_table = table_name_(); + setState(3964); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM) { + { + setState(3963); + from_clause(); + } + } + + } + } + break; + case TABLE: + { + { + setState(3966); + match(TABLE); + setState(3968); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(3967); + match(ONLY); + } + } + + setState(3970); + table_name_(); + setState(3972); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STAR) { + { + setState(3971); + match(STAR); + } + } + + } + } + break; + case OPEN_PAREN: + { + { + setState(3975); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3974); + match(OPEN_PAREN); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3977); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,430,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(3979); + select_stmt(); + setState(3981); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3980); + match(CLOSE_PAREN); + } + } + setState(3983); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==CLOSE_PAREN ); + setState(3985); + combine_clause(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3990); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WHERE) { + { + setState(3989); + where_clause(); + } + } + + setState(3993); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==GROUP) { + { + setState(3992); + group_by_clause(); + } + } + + setState(3996); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==HAVING) { + { + setState(3995); + having_clause(); + } + } + + setState(3999); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WINDOW) { + { + setState(3998); + window_clause(); + } + } + + setState(4002); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXCEPT || _la==INTERSECT || _la==UNION) { + { + setState(4001); + combine_clause(); + } + } + + setState(4005); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ORDER) { + { + setState(4004); + order_by_clause(); + } + } + + setState(4008); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LIMIT) { + { + setState(4007); + limit_clause(); + } + } + + setState(4011); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OFFSET) { + { + setState(4010); + offset_clause(); + } + } + + setState(4014); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FETCH) { + { + setState(4013); + fetch_clause(); + } + } + + setState(4017); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(4016); + 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 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) { + 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, 348, RULE_with_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4019); + match(WITH); + setState(4021); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,443,_ctx) ) { + case 1: + { + setState(4020); + match(RECURSIVE); + } + break; + } + setState(4023); + with_expr(); + setState(4028); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4024); + match(COMMA); + setState(4025); + with_expr(); + } + } + setState(4030); + _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(4031); + table_name_(); + setState(4036); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(4032); + match(OPEN_PAREN); + setState(4033); + name_list(); + setState(4034); + match(CLOSE_PAREN); + } + } + + setState(4038); + match(AS); + setState(4039); + match(OPEN_PAREN); + setState(4045); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,446,_ctx) ) { + case 1: + { + setState(4040); + select_stmt(); + } + break; + case 2: + { + setState(4041); + insert_stmt(); + } + break; + case 3: + { + setState(4042); + delete_stmt(); + } + break; + case 4: + { + setState(4043); + update_stmt(); + } + break; + case 5: + { + setState(4044); + values_stmt(); + } + break; + } + setState(4047); + 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(4070); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,451,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4049); + match(SET); + setState(4051); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,447,_ctx) ) { + case 1: + { + setState(4050); + _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(4053); + ((Set_stmtContext)_localctx).configuration_parameter = identifier(0); + setState(4054); + _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(4057); + _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_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 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 NUMERIC_LITERAL: + case INTEGER_LITERAL: + case SINGLEQ_STRING_LITERAL: + case DOUBLEQ_STRING_LITERAL: + case IDENTIFIER: + case IDENTIFIER_UNICODE: + { + setState(4055); + ((Set_stmtContext)_localctx).value = param_value(); + } + break; + case DEFAULT: + { + setState(4056); + match(DEFAULT); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4059); + match(SET); + setState(4061); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOCAL || _la==SESSION) { + { + setState(4060); + _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(4063); + match(TIME); + setState(4064); + match(ZONE); + setState(4068); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NUMERIC_LITERAL: + case INTEGER_LITERAL: + case SINGLEQ_STRING_LITERAL: + case DOUBLEQ_STRING_LITERAL: + { + setState(4065); + timezone(); + } + break; + case LOCAL: + { + setState(4066); + match(LOCAL); + } + break; + case DEFAULT: + { + setState(4067); + match(DEFAULT); + } + 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 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 Set_constraints_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_constraints_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_constraints_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_constraints_stmt(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; + try { + enterOuterAlt(_localctx, 1); + { + setState(4072); + match(SET); + setState(4073); + match(CONSTRAINTS); + setState(4076); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ALL: + { + setState(4074); + 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_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 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(4075); + ((Set_constraints_stmtContext)_localctx).constraints = identifier_list(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(4078); + _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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_set_role_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterSet_role_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitSet_role_stmt(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(4091); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SET: + enterOuterAlt(_localctx, 1); + { + setState(4080); + match(SET); + setState(4082); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LOCAL || _la==SESSION) { + { + setState(4081); + _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(4084); + match(ROLE); + setState(4087); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,454,_ctx) ) { + case 1: + { + setState(4085); + ((Set_role_stmtContext)_localctx).role_name_ = role_name(); + } + break; + case 2: + { + setState(4086); + match(NONE); + } + break; + } + } + break; + case RESET: + enterOuterAlt(_localctx, 2); + { + setState(4089); + match(RESET); + setState(4090); + 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); + try { + enterOuterAlt(_localctx, 1); + { + setState(4093); + 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 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(4114); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,458,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4095); + match(ISOLATION); + setState(4096); + match(LEVEL); + setState(4104); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,456,_ctx) ) { + case 1: + { + setState(4097); + match(SERIALIZABLE); + } + break; + case 2: + { + setState(4098); + match(REPEATABLE); + setState(4099); + match(READ); + } + break; + case 3: + { + setState(4100); + match(READ); + setState(4101); + match(COMMITTED); + } + break; + case 4: + { + setState(4102); + match(READ); + setState(4103); + match(UNCOMMITTED); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4106); + match(READ); + setState(4107); + match(WRITE); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4108); + match(READ); + setState(4109); + match(ONLY); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4111); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(4110); + match(NOT); + } + } + + setState(4113); + 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(4116); + transaction_mode(); + setState(4121); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4117); + match(COMMA); + setState(4118); + transaction_mode(); + } + } + setState(4123); + _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(4137); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,460,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4124); + match(SET); + setState(4125); + match(TRANSACTION); + setState(4126); + transaction_mode_list(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4127); + match(SET); + setState(4128); + match(TRANSACTION); + setState(4129); + match(SNAPSHOT); + setState(4130); + ((Set_transaction_stmtContext)_localctx).snapshot_id = match(SINGLEQ_STRING_LITERAL); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4131); + match(SET); + setState(4132); + match(SESSION); + setState(4133); + match(CHARACTERISTICS); + setState(4134); + match(AS); + setState(4135); + match(TRANSACTION); + setState(4136); + 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 TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Show_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_show_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterShow_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitShow_stmt(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(4139); + match(SHOW); + setState(4144); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,461,_ctx) ) { + case 1: + { + setState(4140); + ((Show_stmtContext)_localctx).name = identifier(0); + } + break; + case 2: + { + setState(4141); + match(TIME); + setState(4142); + match(ZONE); + } + break; + case 3: + { + setState(4143); + 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); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4146); + match(TRUNCATE); + setState(4148); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==TABLE) { + { + setState(4147); + match(TABLE); + } + } + + setState(4151); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(4150); + match(ONLY); + } + } + + setState(4153); + table_name_(); + setState(4155); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STAR) { + { + setState(4154); + match(STAR); + } + } + + setState(4162); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(4157); + match(COMMA); + setState(4159); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(4158); + match(ONLY); + } + } + + setState(4161); + identifier_list(); + } + } + + setState(4166); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONTINUE || _la==RESTART) { + { + setState(4164); + _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(4165); + match(IDENTITY); + } + } + + setState(4169); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CASCADE || _la==RESTRICT) { + { + setState(4168); + _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(4171); + match(UNLISTEN); + setState(4174); + _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_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 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(4172); + ((Unlisten_stmtContext)_localctx).channel = identifier(0); + } + break; + case STAR: + { + setState(4173); + 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(4177); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(4176); + with_clause(); + } + } + + setState(4179); + match(UPDATE); + setState(4181); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(4180); + match(ONLY); + } + } + + setState(4183); + table_name_(); + setState(4185); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STAR) { + { + setState(4184); + match(STAR); + } + } + + setState(4191); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,474,_ctx) ) { + case 1: + { + setState(4188); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4187); + match(AS); + } + } + + setState(4190); + ((Update_stmtContext)_localctx).alias_ = identifier(0); + } + break; + } + setState(4193); + match(SET); + setState(4194); + updater_clause(); + setState(4196); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM) { + { + setState(4195); + from_clause(); + } + } + + setState(4203); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,476,_ctx) ) { + case 1: + { + setState(4198); + where_clause(); + } + break; + case 2: + { + { + setState(4199); + match(WHERE); + setState(4200); + match(CURRENT); + setState(4201); + match(OF); + setState(4202); + ((Update_stmtContext)_localctx).cursor_name_ = identifier(0); + } + } + break; + } + setState(4206); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==RETURNING) { + { + setState(4205); + 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(4208); + _la = _input.LA(1); + if ( !(_la==ANALYZE || ((((_la - 180)) & ~0x3f) == 0 && ((1L << (_la - 180)) & 180143985094819841L) != 0) || _la==VERBOSE) ) { + _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 Vacuum_opt_listContext extends ParserRuleContext { + public List vacuum_opt() { + return getRuleContexts(Vacuum_optContext.class); + } + public Vacuum_optContext vacuum_opt(int i) { + return getRuleContext(Vacuum_optContext.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Vacuum_opt_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vacuum_opt_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterVacuum_opt_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitVacuum_opt_list(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); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4210); + vacuum_opt(); + setState(4215); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4211); + match(COMMA); + setState(4212); + vacuum_opt(); + } + } + setState(4217); + _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(4265); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,490,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4218); + match(VACUUM); + setState(4223); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(4219); + match(OPEN_PAREN); + setState(4220); + vacuum_opt_list(); + setState(4221); + match(CLOSE_PAREN); + } + } + + { + setState(4225); + ((Vacuum_stmtContext)_localctx).table_name = table_name_(); + setState(4230); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(4226); + match(OPEN_PAREN); + setState(4227); + column_list(); + setState(4228); + match(CLOSE_PAREN); + } + } + + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4232); + match(VACUUM); + setState(4234); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FULL) { + { + setState(4233); + match(FULL); + } + } + + setState(4237); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FREEZE) { + { + setState(4236); + match(FREEZE); + } + } + + setState(4240); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VERBOSE) { + { + setState(4239); + match(VERBOSE); + } + } + + setState(4243); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3170536334544601087L) != 0)) { + { + setState(4242); + ((Vacuum_stmtContext)_localctx).table_name = table_name_(); + } + } + + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4245); + match(VACUUM); + setState(4247); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FULL) { + { + setState(4246); + match(FULL); + } + } + + setState(4250); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FREEZE) { + { + setState(4249); + match(FREEZE); + } + } + + setState(4253); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==VERBOSE) { + { + setState(4252); + match(VERBOSE); + } + } + + setState(4255); + match(ANALYZE); + setState(4263); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3170536334544601087L) != 0)) { + { + setState(4256); + ((Vacuum_stmtContext)_localctx).table_name = table_name_(); + setState(4261); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(4257); + match(OPEN_PAREN); + setState(4258); + column_list(); + setState(4259); + 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 Values_stmtContext extends ParserRuleContext { + public With_clauseContext with_clause() { + return getRuleContext(With_clauseContext.class,0); + } + public Order_by_clauseContext order_by_clause() { + return getRuleContext(Order_by_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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_values_stmt; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterValues_stmt(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitValues_stmt(this); + } + } + + public final Values_stmtContext values_stmt() throws RecognitionException { + Values_stmtContext _localctx = new Values_stmtContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_values_stmt); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4268); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(4267); + with_clause(); + } + } + + setState(4285); + _errHandler.sync(this); + switch (_input.LA(1)) { + case VALUES: + { + { + setState(4270); + match(VALUES); + setState(4271); + expr_list_list(); + } + } + break; + case OPEN_PAREN: + { + { + setState(4273); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4272); + match(OPEN_PAREN); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4275); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,492,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(4277); + values_stmt(); + setState(4279); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4278); + match(CLOSE_PAREN); + } + } + setState(4281); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==CLOSE_PAREN ); + setState(4283); + combine_clause(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4288); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,495,_ctx) ) { + case 1: + { + setState(4287); + order_by_clause(); + } + break; + } + setState(4291); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,496,_ctx) ) { + case 1: + { + setState(4290); + combine_clause(); + } + break; + } + setState(4294); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,497,_ctx) ) { + case 1: + { + setState(4293); + limit_clause(); + } + break; + } + setState(4297); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,498,_ctx) ) { + case 1: + { + setState(4296); + offset_clause(); + } + break; + } + setState(4300); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,499,_ctx) ) { + case 1: + { + setState(4299); + fetch_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 Selector_clauseContext extends ParserRuleContext { + public Column_listContext column_list() { + return getRuleContext(Column_listContext.class,0); + } + public TerminalNode ALL() { return getToken(PostgreSqlParser.ALL, 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 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(4308); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,501,_ctx) ) { + case 1: + { + setState(4302); + match(ALL); + } + break; + case 2: + { + { + setState(4303); + match(DISTINCT); + setState(4306); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(4304); + match(ON); + setState(4305); + expr_list(); + } + } + + } + } + break; + } + setState(4310); + 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(4312); + match(FROM); + setState(4313); + from_item(0); + setState(4318); + _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(4314); + match(COMMA); + setState(4315); + from_item(0); + } + } + } + setState(4320); + _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(4321); + match(WHERE); + setState(4322); + 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(4324); + match(GROUP); + setState(4325); + match(BY); + setState(4326); + grouping_elem(); + setState(4331); + _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(4327); + match(COMMA); + setState(4328); + grouping_elem(); + } + } + } + setState(4333); + _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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grouping_elem; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrouping_elem(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrouping_elem(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; + try { + setState(4359); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,507,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4334); + match(OPEN_PAREN); + setState(4335); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4336); + expr(0); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4337); + expr_list(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4338); + _la = _input.LA(1); + if ( !(_la==CUBE || _la==ROLLUP) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4339); + match(OPEN_PAREN); + setState(4342); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,504,_ctx) ) { + case 1: + { + setState(4340); + expr(0); + } + break; + case 2: + { + setState(4341); + expr_list(); + } + break; + } + setState(4351); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4344); + match(COMMA); + setState(4347); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,505,_ctx) ) { + case 1: + { + setState(4345); + expr(0); + } + break; + case 2: + { + setState(4346); + expr_list(); + } + break; + } + } + } + setState(4353); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4354); + match(CLOSE_PAREN); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4356); + match(GROUPING); + setState(4357); + match(SETS); + setState(4358); + grouping_elem_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 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 Grouping_elemContext grouping_elem(int i) { + return getRuleContext(Grouping_elemContext.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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_grouping_elem_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterGrouping_elem_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitGrouping_elem_list(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); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4361); + match(OPEN_PAREN); + setState(4362); + grouping_elem(); + setState(4367); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4363); + match(COMMA); + setState(4364); + grouping_elem(); + } + } + setState(4369); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4370); + 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 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 Having_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_having_clause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterHaving_clause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitHaving_clause(this); + } + } + + public final Having_clauseContext having_clause() throws RecognitionException { + Having_clauseContext _localctx = new Having_clauseContext(_ctx, getState()); + enterRule(_localctx, 394, RULE_having_clause); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4372); + match(HAVING); + setState(4373); + predicate(0); + setState(4378); + _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(4374); + match(COMMA); + setState(4375); + predicate(0); + } + } + } + setState(4380); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,509,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_column_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_list(this); + } + } + + public final Column_listContext column_list() throws RecognitionException { + Column_listContext _localctx = new Column_listContext(_ctx, getState()); + enterRule(_localctx, 396, RULE_column_list); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4389); + _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_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 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: + { + { + setState(4381); + ((Column_listContext)_localctx).column_name_ = expr(0); + setState(4386); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,511,_ctx) ) { + case 1: + { + setState(4383); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4382); + match(AS); + } + } + + setState(4385); + ((Column_listContext)_localctx).output_name = name_(); + } + break; + } + } + } + break; + case STAR: + { + setState(4388); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + setState(4404); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,516,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4391); + match(COMMA); + setState(4400); + _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_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 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: + { + { + setState(4392); + ((Column_listContext)_localctx).column_name_ = expr(0); + setState(4397); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,514,_ctx) ) { + case 1: + { + setState(4394); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(4393); + match(AS); + } + } + + setState(4396); + ((Column_listContext)_localctx).output_name = name_(); + } + break; + } + } + } + break; + case STAR: + { + setState(4399); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(4406); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,516,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explain_parameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExplain_parameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExplain_parameter(this); + } + } + + public final Explain_parameterContext explain_parameter() throws RecognitionException { + Explain_parameterContext _localctx = new Explain_parameterContext(_ctx, getState()); + enterRule(_localctx, 398, RULE_explain_parameter); + int _la; + try { + setState(4413); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ANALYZE: + case BUFFERS: + case COSTS: + case TIMING: + case VERBOSE: + enterOuterAlt(_localctx, 1); + { + setState(4407); + _la = _input.LA(1); + if ( !(_la==ANALYZE || _la==BUFFERS || _la==COSTS || _la==TIMING || _la==VERBOSE) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4409); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 119L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3341673120384679935L) != 0)) { + { + setState(4408); + param_value(); + } + } + + } + break; + case FORMAT: + enterOuterAlt(_localctx, 2); + { + setState(4411); + match(FORMAT); + setState(4412); + _la = _input.LA(1); + if ( !(_la==YAML || ((((_la - 735)) & ~0x3f) == 0 && ((1L << (_la - 735)) & 33685505L) != 0)) ) { + _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 FrameContext extends ParserRuleContext { + public TerminalNode UNBOUNDED() { return getToken(PostgreSqlParser.UNBOUNDED, 0); } + public TerminalNode PRECEDING() { return getToken(PostgreSqlParser.PRECEDING, 0); } + public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 0); } + 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frame; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame(this); + } + } + + public final FrameContext frame() throws RecognitionException { + FrameContext _localctx = new FrameContext(_ctx, getState()); + enterRule(_localctx, 400, RULE_frame); + try { + setState(4425); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,519,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4415); + match(UNBOUNDED); + setState(4416); + match(PRECEDING); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4417); + match(INTEGER_LITERAL); + setState(4418); + match(PRECEDING); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4419); + match(CURRENT); + setState(4420); + match(ROW); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4421); + match(INTEGER_LITERAL); + setState(4422); + match(FOLLOWING); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(4423); + match(UNBOUNDED); + setState(4424); + match(FOLLOWING); + } + 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_startContext extends ParserRuleContext { + public FrameContext frame() { + return getRuleContext(FrameContext.class,0); + } + public Frame_startContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_frame_start; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFrame_start(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFrame_start(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(4427); + 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(4429); + 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); + int _la; + try { + setState(4439); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,520,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4431); + _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(4432); + frame_start(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4433); + _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(4434); + match(BETWEEN); + setState(4435); + frame_start(); + setState(4436); + match(AND); + setState(4437); + frame_end(); + } + 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_definitionContext extends ParserRuleContext { + public Window_nameContext window_name() { + return getRuleContext(Window_nameContext.class,0); + } + 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 Order_by_clauseContext order_by_clause() { + return getRuleContext(Order_by_clauseContext.class,0); + } + public Window_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_window_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWindow_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWindow_definition(this); + } + } + + public final Window_definitionContext window_definition() throws RecognitionException { + Window_definitionContext _localctx = new Window_definitionContext(_ctx, getState()); + enterRule(_localctx, 408, RULE_window_definition); + int _la; + try { + setState(4453); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,522,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4441); + window_name(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4442); + match(PARTITION); + setState(4443); + match(BY); + setState(4444); + expr(0); + setState(4449); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4445); + match(COMMA); + setState(4446); + expr(0); + } + } + setState(4451); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4452); + order_by_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 Window_clauseContext extends ParserRuleContext { + public TerminalNode WINDOW() { return getToken(PostgreSqlParser.WINDOW, 0); } + public Window_nameContext window_name() { + return getRuleContext(Window_nameContext.class,0); + } + public TerminalNode AS() { return getToken(PostgreSqlParser.AS, 0); } + public TerminalNode OPEN_PAREN() { return getToken(PostgreSqlParser.OPEN_PAREN, 0); } + public Window_definitionContext window_definition() { + return getRuleContext(Window_definitionContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(PostgreSqlParser.CLOSE_PAREN, 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, 410, RULE_window_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(4455); + match(WINDOW); + setState(4456); + window_name(); + setState(4457); + match(AS); + setState(4458); + match(OPEN_PAREN); + setState(4459); + window_definition(); + setState(4460); + 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 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, 412, RULE_combine_clause); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4462); + _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(4464); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ALL || _la==DISTINCT) { + { + setState(4463); + _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(4469); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,524,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4466); + match(OPEN_PAREN); + } + } + } + setState(4471); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,524,_ctx); + } + setState(4474); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,525,_ctx) ) { + case 1: + { + setState(4472); + select_stmt(); + } + break; + case 2: + { + setState(4473); + values_stmt(); + } + break; + } + setState(4479); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,526,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4476); + match(CLOSE_PAREN); + } + } + } + setState(4481); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,526,_ctx); + } + setState(4483); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,527,_ctx) ) { + case 1: + { + setState(4482); + 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, 414, RULE_order_by_clause); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4485); + match(ORDER); + setState(4486); + match(BY); + setState(4487); + order_by_item(); + setState(4492); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,528,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4488); + match(COMMA); + setState(4489); + order_by_item(); + } + } + } + setState(4494); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,528,_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, 416, RULE_order_by_item); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4497); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,529,_ctx) ) { + case 1: + { + setState(4495); + expr(0); + } + break; + case 2: + { + setState(4496); + match(DOUBLEQ_STRING_LITERAL); + } + break; + } + setState(4503); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,530,_ctx) ) { + case 1: + { + setState(4499); + match(ASC); + } + break; + case 2: + { + setState(4500); + match(DESC); + } + break; + case 3: + { + setState(4501); + match(USING); + setState(4502); + expr(0); + } + break; + } + setState(4516); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,532,_ctx) ) { + case 1: + { + { + setState(4505); + match(NULLS); + setState(4506); + _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(4513); + _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(4508); + match(COMMA); + { + setState(4509); + match(NULLS); + setState(4510); + _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(4515); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,531,_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 TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 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, 418, RULE_limit_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(4518); + match(LIMIT); + setState(4522); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INTEGER_LITERAL: + { + setState(4519); + match(INTEGER_LITERAL); + } + break; + case ALL: + { + setState(4520); + 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_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 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(4521); + 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 TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 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, 420, RULE_offset_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4524); + match(OFFSET); + setState(4525); + match(INTEGER_LITERAL); + setState(4527); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,534,_ctx) ) { + case 1: + { + setState(4526); + _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 TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 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, 422, RULE_fetch_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4529); + match(FETCH); + setState(4530); + _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(4532); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTEGER_LITERAL) { + { + setState(4531); + match(INTEGER_LITERAL); + } + } + + setState(4534); + _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(4535); + 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, 424, RULE_for_clause); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4537); + match(FOR); + setState(4545); + _errHandler.sync(this); + switch (_input.LA(1)) { + case UPDATE: + { + setState(4538); + match(UPDATE); + } + break; + case NO: + { + setState(4539); + match(NO); + setState(4540); + match(KEY); + setState(4541); + match(UPDATE); + } + break; + case SHARE: + { + setState(4542); + match(SHARE); + } + break; + case KEY: + { + setState(4543); + match(KEY); + setState(4544); + match(SHARE); + } + break; + default: + throw new NoViableAltException(this); + } + setState(4556); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,538,_ctx) ) { + case 1: + { + setState(4547); + match(OF); + setState(4548); + table_name_(); + setState(4553); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,537,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4549); + match(COMMA); + setState(4550); + table_name_(); + } + } + } + setState(4555); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,537,_ctx); + } + } + break; + } + setState(4563); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,540,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + setState(4561); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOWAIT: + { + setState(4558); + match(NOWAIT); + } + break; + case SKIP_: + { + setState(4559); + match(SKIP_); + setState(4560); + match(LOCKED); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(4565); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,540,_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, 426, RULE_updater_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4566); + updater_expr(); + setState(4571); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4567); + match(COMMA); + setState(4568); + updater_expr(); + } + } + setState(4573); + _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, 428, RULE_updater_expr); + try { + setState(4583); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,543,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4574); + expr(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + { + setState(4575); + match(OPEN_PAREN); + setState(4576); + name_list(); + setState(4577); + match(CLOSE_PAREN); + setState(4578); + match(EQUAL); + setState(4581); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,542,_ctx) ) { + case 1: + { + setState(4579); + expr(0); + } + break; + case 2: + { + setState(4580); + expr_list(); + } + 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 Returning_clauseContext extends ParserRuleContext { + public TerminalNode RETURNING() { return getToken(PostgreSqlParser.RETURNING, 0); } + public Column_listContext column_list() { + return getRuleContext(Column_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, 430, RULE_returning_clause); + try { + enterOuterAlt(_localctx, 1); + { + setState(4585); + match(RETURNING); + setState(4586); + 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 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 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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr(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 = 432; + enterRecursionRule(_localctx, 432, RULE_expr, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4663); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,546,_ctx) ) { + case 1: + { + setState(4589); + match(NULL); + } + break; + case 2: + { + setState(4590); + match(CURRENT_DATE); + } + break; + case 3: + { + setState(4591); + match(CURRENT_ROLE); + } + break; + case 4: + { + setState(4592); + match(CURRENT_TIME); + } + break; + case 5: + { + setState(4593); + match(CURRENT_TIMESTAMP); + } + break; + case 6: + { + setState(4594); + match(CURRENT_USER); + } + break; + case 7: + { + setState(4595); + match(DEFAULT); + } + break; + case 8: + { + setState(4596); + match(INTEGER_LITERAL); + } + break; + case 9: + { + setState(4597); + match(HEX_INTEGER_LITERAL); + } + break; + case 10: + { + setState(4598); + match(NUMERIC_LITERAL); + } + break; + case 11: + { + setState(4599); + match(SINGLEQ_STRING_LITERAL); + } + break; + case 12: + { + setState(4600); + match(BIT_STRING); + } + break; + case 13: + { + setState(4601); + match(REGEX_STRING); + } + break; + case 14: + { + setState(4602); + match(DOLLAR_DOLLAR); + setState(4604); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4603); + _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(4606); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,544,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(4608); + match(DOLLAR_DOLLAR); + } + break; + case 15: + { + setState(4609); + match(DOLLAR); + setState(4610); + identifier(0); + setState(4612); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4611); + _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(4614); + _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)) & -1152921504606846977L) != 0) || ((((_la - 768)) & ~0x3f) == 0 && ((1L << (_la - 768)) & -1L) != 0) || ((((_la - 832)) & ~0x3f) == 0 && ((1L << (_la - 832)) & 31L) != 0) ); + setState(4616); + match(DOLLAR); + setState(4617); + identifier(0); + setState(4618); + match(DOLLAR); + } + break; + case 16: + { + setState(4620); + bool_expr(0); + } + break; + case 17: + { + setState(4621); + values_stmt(); + } + break; + case 18: + { + setState(4622); + expr_list(); + } + break; + case 19: + { + setState(4623); + match(OPEN_PAREN); + setState(4624); + expr(0); + setState(4625); + match(CLOSE_PAREN); + } + break; + case 20: + { + setState(4627); + type_name(); + setState(4628); + match(SINGLEQ_STRING_LITERAL); + } + break; + case 21: + { + setState(4630); + ((ExprContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 787)) & ~0x3f) == 0 && ((1L << (_la - 787)) & 8724152325L) != 0)) ) { + ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4631); + expr(31); + } + break; + case 22: + { + setState(4632); + ((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(4633); + expr(30); + } + break; + case 23: + { + setState(4634); + ((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(4635); + expr(18); + } + break; + case 24: + { + setState(4636); + func_call(); + } + break; + case 25: + { + setState(4637); + identifier(0); + } + break; + case 26: + { + setState(4638); + match(CAST); + setState(4639); + match(OPEN_PAREN); + setState(4640); + expr(0); + setState(4641); + match(AS); + setState(4642); + data_type(); + setState(4643); + match(CLOSE_PAREN); + } + break; + case 27: + { + setState(4645); + correlation_name(); + setState(4646); + match(DOT); + setState(4647); + column_name(); + } + break; + case 28: + { + setState(4649); + case_expr(); + } + break; + case 29: + { + setState(4650); + data_type(); + setState(4651); + expr(10); + } + break; + case 30: + { + setState(4653); + aggregate(); + } + break; + case 31: + { + setState(4654); + array_cons_expr(); + } + break; + case 32: + { + setState(4655); + match(EXISTS); + setState(4656); + expr(4); + } + break; + case 33: + { + setState(4657); + match(DOLLAR_DEC); + } + break; + case 34: + { + setState(4658); + match(OPEN_PAREN); + setState(4659); + select_stmt(); + setState(4660); + match(CLOSE_PAREN); + } + break; + case 35: + { + setState(4662); + parameter(); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(4764); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,557,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(4762); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,556,_ctx) ) { + case 1: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4665); + if (!(precpred(_ctx, 28))) throw new FailedPredicateException(this, "precpred(_ctx, 28)"); + setState(4666); + ((ExprContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 791)) & ~0x3f) == 0 && ((1L << (_la - 791)) & 402653185L) != 0)) ) { + ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4667); + expr(29); + } + break; + case 2: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4668); + if (!(precpred(_ctx, 27))) throw new FailedPredicateException(this, "precpred(_ctx, 27)"); + setState(4669); + ((ExprContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 766)) & ~0x3f) == 0 && ((1L << (_la - 766)) & 1153484454560268289L) != 0)) ) { + ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4670); + expr(28); + } + break; + case 3: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4671); + if (!(precpred(_ctx, 26))) throw new FailedPredicateException(this, "precpred(_ctx, 26)"); + setState(4672); + ((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(4673); + expr(27); + } + break; + case 4: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4674); + if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); + setState(4675); + ((ExprContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==AND || _la==NOT || _la==OR || ((((_la - 782)) & ~0x3f) == 0 && ((1L << (_la - 782)) & 8984714941548575L) != 0)) ) { + ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4676); + expr(26); + } + break; + case 5: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4677); + if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); + setState(4681); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOT: + { + setState(4678); + match(NOT); + setState(4679); + match(LIKE); + } + break; + case LIKE: + { + setState(4680); + match(LIKE); + } + break; + default: + throw new NoViableAltException(this); + } + setState(4683); + expr(25); + } + break; + case 6: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4684); + if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)"); + setState(4686); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(4685); + match(NOT); + } + } + + setState(4688); + match(BETWEEN); + setState(4689); + expr(0); + setState(4690); + match(AND); + setState(4691); + expr(24); + } + break; + case 7: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4693); + if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(4694); + match(IN); + setState(4695); + expr(23); + } + break; + case 8: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4696); + if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); + setState(4697); + ((ExprContext)_localctx).op = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 790)) & ~0x3f) == 0 && ((1L << (_la - 790)) & 622645L) != 0)) ) { + ((ExprContext)_localctx).op = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(4698); + expr(22); + } + break; + case 9: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4699); + if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); + setState(4700); + match(IS); + setState(4702); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(4701); + match(NOT); + } + } + + setState(4704); + match(DISTINCT); + setState(4705); + match(FROM); + setState(4706); + expr(20); + } + break; + case 10: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4707); + if (!(precpred(_ctx, 34))) throw new FailedPredicateException(this, "precpred(_ctx, 34)"); + setState(4708); + match(OPEN_BRACKET); + setState(4709); + expr(0); + setState(4710); + match(CLOSE_BRACKET); + } + break; + case 11: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4712); + if (!(precpred(_ctx, 29))) throw new FailedPredicateException(this, "precpred(_ctx, 29)"); + setState(4713); + ((ExprContext)_localctx).op = match(BANG); + } + break; + case 12: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4714); + if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); + setState(4715); + ((ExprContext)_localctx).op = match(IS); + setState(4720); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,550,_ctx) ) { + case 1: + { + setState(4716); + bool_expr(0); + } + break; + case 2: + { + setState(4717); + match(NULL); + } + break; + case 3: + { + setState(4718); + match(NOT); + setState(4719); + match(NULL); + } + break; + } + } + break; + case 13: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4722); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(4732); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4723); + match(OPEN_BRACKET); + setState(4725); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,551,_ctx) ) { + case 1: + { + setState(4724); + expr(0); + } + break; + } + setState(4727); + match(COLON); + setState(4729); + _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)) & -3051208608109821955L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 4537576733544546303L) != 0) || ((((_la - 787)) & ~0x3f) == 0 && ((1L << (_la - 787)) & 1262854602757L) != 0)) { + { + setState(4728); + expr(0); + } + } + + setState(4731); + match(CLOSE_BRACKET); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4734); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,553,_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(4736); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(4739); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(4737); + match(COLON_COLON); + setState(4738); + data_type(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(4741); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,554,_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(4743); + if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(4744); + match(IS); + setState(4745); + match(OF); + setState(4746); + match(OPEN_PAREN); + setState(4747); + data_type(); + setState(4748); + match(CLOSE_PAREN); + } + break; + case 16: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4750); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(4751); + match(DOT); + setState(4754); + _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_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 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(4752); + identifier(0); + } + break; + case STAR: + { + setState(4753); + match(STAR); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 17: + { + _localctx = new ExprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expr); + setState(4756); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + { + setState(4757); + match(AT); + setState(4758); + match(TIME); + setState(4759); + match(ZONE); + } + setState(4761); + match(SINGLEQ_STRING_LITERAL); + } + break; + } + } + } + setState(4766); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,557,_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 ParameterContext extends ParserRuleContext { + public Token prefix; + public TerminalNode SPEL() { return getToken(PostgreSqlParser.SPEL, 0); } + public TerminalNode COLON() { return getToken(PostgreSqlParser.COLON, 0); } + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public TerminalNode QMARK() { return getToken(PostgreSqlParser.QMARK, 0); } + public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 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, 434, RULE_parameter); + try { + setState(4777); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,559,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4767); + ((ParameterContext)_localctx).prefix = match(COLON); + setState(4768); + match(SPEL); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4769); + ((ParameterContext)_localctx).prefix = match(COLON); + setState(4770); + identifier(0); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(4771); + ((ParameterContext)_localctx).prefix = match(QMARK); + setState(4772); + match(SPEL); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(4773); + ((ParameterContext)_localctx).prefix = match(QMARK); + setState(4775); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,558,_ctx) ) { + case 1: + { + setState(4774); + match(INTEGER_LITERAL); + } + 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 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 = 436; + enterRecursionRule(_localctx, 436, RULE_bool_expr, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4784); + _errHandler.sync(this); + switch (_input.LA(1)) { + case TRUE: + { + setState(4780); + match(TRUE); + } + break; + case FALSE: + { + setState(4781); + match(FALSE); + } + break; + case NOT: + { + setState(4782); + match(NOT); + setState(4783); + bool_expr(3); + } + break; + default: + throw new NoViableAltException(this); + } + _ctx.stop = _input.LT(-1); + setState(4794); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,562,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(4792); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,561,_ctx) ) { + case 1: + { + _localctx = new Bool_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_bool_expr); + setState(4786); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(4787); + match(AND); + setState(4788); + bool_expr(3); + } + break; + case 2: + { + _localctx = new Bool_exprContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_bool_expr); + setState(4789); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(4790); + match(OR); + setState(4791); + bool_expr(2); + } + break; + } + } + } + setState(4796); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,562,_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 Case_exprContext extends ParserRuleContext { + public TerminalNode CASE() { return getToken(PostgreSqlParser.CASE, 0); } + public List expr() { + return getRuleContexts(ExprContext.class); + } + public ExprContext expr(int i) { + return getRuleContext(ExprContext.class,i); + } + 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) { + 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, 438, RULE_case_expr); + int _la; + try { + setState(4830); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,567,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(4797); + match(CASE); + setState(4798); + expr(0); + setState(4804); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4799); + match(WHEN); + setState(4800); + expr(0); + setState(4801); + match(THEN); + setState(4802); + expr(0); + } + } + setState(4806); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + setState(4810); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(4808); + match(ELSE); + setState(4809); + expr(0); + } + } + + setState(4812); + match(END); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(4814); + match(CASE); + setState(4820); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(4815); + match(WHEN); + setState(4816); + predicate(0); + setState(4817); + match(THEN); + setState(4818); + expr(0); + } + } + setState(4822); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==WHEN ); + setState(4826); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(4824); + match(ELSE); + setState(4825); + expr(0); + } + } + + setState(4828); + match(END); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @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 ExprContext expr(int i) { + return getRuleContext(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 Expr_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterExpr_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitExpr_list(this); + } + } + + public final Expr_listContext expr_list() throws RecognitionException { + Expr_listContext _localctx = new Expr_listContext(_ctx, getState()); + enterRule(_localctx, 440, RULE_expr_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4832); + match(OPEN_PAREN); + setState(4833); + expr(0); + setState(4838); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4834); + match(COMMA); + setState(4835); + expr(0); + } + } + setState(4840); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(4841); + 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, 442, RULE_expr_list_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(4844); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,569,_ctx) ) { + case 1: + { + setState(4843); + match(OPEN_PAREN); + } + break; + } + setState(4846); + expr_list(); + setState(4851); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,570,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(4847); + match(COMMA); + setState(4848); + expr_list(); + } + } + } + setState(4853); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,570,_ctx); + } + setState(4855); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,571,_ctx) ) { + case 1: + { + setState(4854); + 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, 444, RULE_func_sig_arg); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4864); + _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)) & -7658391026909839363L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 3170536334544601087L) != 0)) { + { + setState(4858); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,572,_ctx) ) { + case 1: + { + setState(4857); + ((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(4861); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,573,_ctx) ) { + case 1: + { + setState(4860); + ((Func_sig_argContext)_localctx).argname = identifier(0); + } + break; + } + setState(4863); + ((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, 446, RULE_func_sig_arg_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4866); + func_sig_arg(); + setState(4871); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4867); + match(COMMA); + setState(4868); + func_sig_arg(); + } + } + setState(4873); + _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, 448, RULE_func_sig); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4874); + ((Func_sigContext)_localctx).name = identifier(0); + setState(4879); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(4875); + match(OPEN_PAREN); + setState(4876); + func_sig_arg_list(); + setState(4877); + 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, 450, RULE_func_sig_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(4881); + func_sig(); + setState(4886); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(4882); + match(COMMA); + setState(4883); + func_sig(); + } + } + setState(4888); + _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, 452, RULE_type_name); + int _la; + try { + setState(5033); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ABSTIME: + enterOuterAlt(_localctx, 1); + { + setState(4889); + match(ABSTIME); + } + break; + case RELTIME: + enterOuterAlt(_localctx, 2); + { + setState(4890); + match(RELTIME); + } + break; + case BIGINT: + enterOuterAlt(_localctx, 3); + { + setState(4891); + match(BIGINT); + } + break; + case BIGSERIAL: + enterOuterAlt(_localctx, 4); + { + setState(4892); + match(BIGSERIAL); + } + break; + case BIT: + enterOuterAlt(_localctx, 5); + { + setState(4893); + match(BIT); + setState(4897); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,578,_ctx) ) { + case 1: + { + setState(4894); + match(OPEN_PAREN); + setState(4895); + match(INTEGER_LITERAL); + setState(4896); + match(CLOSE_PAREN); + } + break; + } + } + break; + case BIT_VARYING: + enterOuterAlt(_localctx, 6); + { + setState(4899); + match(BIT_VARYING); + setState(4903); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,579,_ctx) ) { + case 1: + { + setState(4900); + match(OPEN_PAREN); + setState(4901); + match(INTEGER_LITERAL); + setState(4902); + match(CLOSE_PAREN); + } + break; + } + } + break; + case BOOL: + enterOuterAlt(_localctx, 7); + { + setState(4905); + match(BOOL); + } + break; + case BOOLEAN: + enterOuterAlt(_localctx, 8); + { + setState(4906); + match(BOOLEAN); + } + break; + case BOX: + enterOuterAlt(_localctx, 9); + { + setState(4907); + match(BOX); + } + break; + case BYTEA: + enterOuterAlt(_localctx, 10); + { + setState(4908); + match(BYTEA); + } + break; + case CHAR: + enterOuterAlt(_localctx, 11); + { + setState(4909); + match(CHAR); + setState(4913); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,580,_ctx) ) { + case 1: + { + setState(4910); + match(OPEN_PAREN); + setState(4911); + match(INTEGER_LITERAL); + setState(4912); + match(CLOSE_PAREN); + } + break; + } + } + break; + case CHARACTER: + enterOuterAlt(_localctx, 12); + { + setState(4915); + match(CHARACTER); + setState(4919); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,581,_ctx) ) { + case 1: + { + setState(4916); + match(OPEN_PAREN); + setState(4917); + match(INTEGER_LITERAL); + setState(4918); + match(CLOSE_PAREN); + } + break; + } + } + break; + case CHARACTER_VARYING: + enterOuterAlt(_localctx, 13); + { + setState(4921); + match(CHARACTER_VARYING); + setState(4925); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,582,_ctx) ) { + case 1: + { + setState(4922); + match(OPEN_PAREN); + setState(4923); + match(INTEGER_LITERAL); + setState(4924); + match(CLOSE_PAREN); + } + break; + } + } + break; + case CIDR: + enterOuterAlt(_localctx, 14); + { + setState(4927); + match(CIDR); + } + break; + case CIRCLE: + enterOuterAlt(_localctx, 15); + { + setState(4928); + match(CIRCLE); + } + break; + case DATE: + enterOuterAlt(_localctx, 16); + { + setState(4929); + match(DATE); + } + break; + case DECIMAL: + enterOuterAlt(_localctx, 17); + { + setState(4930); + match(DECIMAL); + setState(4936); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,583,_ctx) ) { + case 1: + { + setState(4931); + match(OPEN_PAREN); + setState(4932); + match(INTEGER_LITERAL); + setState(4933); + match(COMMA); + setState(4934); + match(INTEGER_LITERAL); + setState(4935); + match(CLOSE_PAREN); + } + break; + } + } + break; + case DOUBLE: + enterOuterAlt(_localctx, 18); + { + setState(4938); + match(DOUBLE); + setState(4939); + match(PRECISION); + } + break; + case FLOAT4: + enterOuterAlt(_localctx, 19); + { + setState(4940); + match(FLOAT4); + } + break; + case FLOAT8: + enterOuterAlt(_localctx, 20); + { + setState(4941); + match(FLOAT8); + } + break; + case INET: + enterOuterAlt(_localctx, 21); + { + setState(4942); + match(INET); + } + break; + case INT: + enterOuterAlt(_localctx, 22); + { + setState(4943); + match(INT); + } + break; + case INT4: + enterOuterAlt(_localctx, 23); + { + setState(4944); + match(INT4); + } + break; + case INT2: + enterOuterAlt(_localctx, 24); + { + setState(4945); + match(INT2); + } + break; + case INT8: + enterOuterAlt(_localctx, 25); + { + setState(4946); + match(INT8); + } + break; + case INTEGER: + enterOuterAlt(_localctx, 26); + { + setState(4947); + match(INTEGER); + } + break; + case INTERVAL: + enterOuterAlt(_localctx, 27); + { + setState(4948); + match(INTERVAL); + setState(4950); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,584,_ctx) ) { + case 1: + { + setState(4949); + match(FIELDS); + } + break; + } + setState(4953); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,585,_ctx) ) { + case 1: + { + setState(4952); + match(INTEGER_LITERAL); + } + break; + } + } + break; + case JSON: + enterOuterAlt(_localctx, 28); + { + setState(4955); + match(JSON); + } + break; + case JSONB: + enterOuterAlt(_localctx, 29); + { + setState(4956); + match(JSONB); + } + break; + case LINE: + enterOuterAlt(_localctx, 30); + { + setState(4957); + match(LINE); + } + break; + case LSEG: + enterOuterAlt(_localctx, 31); + { + setState(4958); + match(LSEG); + } + break; + case MACADDR: + enterOuterAlt(_localctx, 32); + { + setState(4959); + match(MACADDR); + } + break; + case MACADDR8: + enterOuterAlt(_localctx, 33); + { + setState(4960); + match(MACADDR8); + } + break; + case MONEY: + enterOuterAlt(_localctx, 34); + { + setState(4961); + match(MONEY); + } + break; + case NUMERIC: + enterOuterAlt(_localctx, 35); + { + setState(4962); + match(NUMERIC); + setState(4968); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,586,_ctx) ) { + case 1: + { + setState(4963); + match(OPEN_PAREN); + setState(4964); + match(INTEGER_LITERAL); + setState(4965); + match(COMMA); + setState(4966); + match(INTEGER_LITERAL); + setState(4967); + match(CLOSE_PAREN); + } + break; + } + } + break; + case PATH: + enterOuterAlt(_localctx, 36); + { + setState(4970); + match(PATH); + } + break; + case PG_LSN: + enterOuterAlt(_localctx, 37); + { + setState(4971); + match(PG_LSN); + } + break; + case POINT: + enterOuterAlt(_localctx, 38); + { + setState(4972); + match(POINT); + } + break; + case POLYGON: + enterOuterAlt(_localctx, 39); + { + setState(4973); + match(POLYGON); + } + break; + case REAL: + enterOuterAlt(_localctx, 40); + { + setState(4974); + match(REAL); + } + break; + case SERIAL: + enterOuterAlt(_localctx, 41); + { + setState(4975); + match(SERIAL); + } + break; + case SERIAL2: + enterOuterAlt(_localctx, 42); + { + setState(4976); + match(SERIAL2); + } + break; + case SERIAL4: + enterOuterAlt(_localctx, 43); + { + setState(4977); + match(SERIAL4); + } + break; + case SERIAL8: + enterOuterAlt(_localctx, 44); + { + setState(4978); + match(SERIAL8); + } + break; + case SMALLINT: + enterOuterAlt(_localctx, 45); + { + setState(4979); + match(SMALLINT); + } + break; + case SMALLSERIAL: + enterOuterAlt(_localctx, 46); + { + setState(4980); + match(SMALLSERIAL); + } + break; + case TEXT: + enterOuterAlt(_localctx, 47); + { + setState(4981); + match(TEXT); + } + break; + case TIME: + enterOuterAlt(_localctx, 48); + { + setState(4982); + match(TIME); + setState(4986); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,587,_ctx) ) { + case 1: + { + setState(4983); + match(OPEN_PAREN); + setState(4984); + match(INTEGER_LITERAL); + setState(4985); + match(CLOSE_PAREN); + } + break; + } + setState(4991); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,588,_ctx) ) { + case 1: + { + setState(4988); + _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(4989); + match(TIME); + setState(4990); + match(ZONE); + } + break; + } + } + break; + case TIMESTAMP: + enterOuterAlt(_localctx, 49); + { + setState(4993); + match(TIMESTAMP); + setState(4997); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,589,_ctx) ) { + case 1: + { + setState(4994); + match(OPEN_PAREN); + setState(4995); + match(INTEGER_LITERAL); + setState(4996); + match(CLOSE_PAREN); + } + break; + } + setState(5002); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,590,_ctx) ) { + case 1: + { + setState(4999); + _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(5000); + match(TIME); + setState(5001); + match(ZONE); + } + break; + } + } + break; + case TIMETZ: + enterOuterAlt(_localctx, 50); + { + setState(5004); + match(TIMETZ); + setState(5008); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,591,_ctx) ) { + case 1: + { + setState(5005); + match(OPEN_PAREN); + setState(5006); + match(INTEGER_LITERAL); + setState(5007); + match(CLOSE_PAREN); + } + break; + } + } + break; + case TIMESTAMPTZ: + enterOuterAlt(_localctx, 51); + { + setState(5010); + match(TIMESTAMPTZ); + setState(5014); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,592,_ctx) ) { + case 1: + { + setState(5011); + match(OPEN_PAREN); + setState(5012); + match(INTEGER_LITERAL); + setState(5013); + match(CLOSE_PAREN); + } + break; + } + } + break; + case TSQUERY: + enterOuterAlt(_localctx, 52); + { + setState(5016); + match(TSQUERY); + } + break; + case TSVECTOR: + enterOuterAlt(_localctx, 53); + { + setState(5017); + match(TSVECTOR); + } + break; + case TXID_SNAPSHOT: + enterOuterAlt(_localctx, 54); + { + setState(5018); + match(TXID_SNAPSHOT); + } + break; + case UUID: + enterOuterAlt(_localctx, 55); + { + setState(5019); + match(UUID); + } + break; + case VARBIT: + enterOuterAlt(_localctx, 56); + { + setState(5020); + match(VARBIT); + setState(5024); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,593,_ctx) ) { + case 1: + { + setState(5021); + match(OPEN_PAREN); + setState(5022); + match(INTEGER_LITERAL); + setState(5023); + match(CLOSE_PAREN); + } + break; + } + } + break; + case VARCHAR: + enterOuterAlt(_localctx, 57); + { + setState(5026); + match(VARCHAR); + setState(5030); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,594,_ctx) ) { + case 1: + { + setState(5027); + match(OPEN_PAREN); + setState(5028); + match(INTEGER_LITERAL); + setState(5029); + match(CLOSE_PAREN); + } + break; + } + } + break; + case XML: + enterOuterAlt(_localctx, 58); + { + setState(5032); + match(XML); + } + 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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_timezone; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTimezone(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTimezone(this); + } + } + + public final TimezoneContext timezone() throws RecognitionException { + TimezoneContext _localctx = new TimezoneContext(_ctx, getState()); + enterRule(_localctx, 454, RULE_timezone); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5035); + _la = _input.LA(1); + if ( !(((((_la - 773)) & ~0x3f) == 0 && ((1L << (_la - 773)) & 51L) != 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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_oper; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOper(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOper(this); + } + } + + public final OperContext oper() throws RecognitionException { + OperContext _localctx = new OperContext(_ctx, getState()); + enterRule(_localctx, 456, RULE_oper); + try { + setState(5041); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,596,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5038); + match(IS); + setState(5039); + match(OF); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5040); + 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, 458, RULE_aggregate); + int _la; + try { + setState(5106); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,605,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5043); + identifier(0); + setState(5044); + match(OPEN_PAREN); + setState(5046); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,597,_ctx) ) { + case 1: + { + setState(5045); + _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(5048); + expr(0); + setState(5053); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5049); + match(COMMA); + setState(5050); + expr(0); + } + } + setState(5055); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5057); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ORDER) { + { + setState(5056); + order_by_clause(); + } + } + + setState(5059); + match(CLOSE_PAREN); + setState(5066); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,600,_ctx) ) { + case 1: + { + setState(5060); + match(FILTER); + setState(5061); + match(OPEN_PAREN); + setState(5062); + match(WHERE); + setState(5063); + where_clause(); + setState(5064); + match(CLOSE_PAREN); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5068); + identifier(0); + setState(5069); + match(OPEN_PAREN); + setState(5070); + match(STAR); + setState(5071); + match(CLOSE_PAREN); + setState(5078); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,601,_ctx) ) { + case 1: + { + setState(5072); + match(FILTER); + setState(5073); + match(OPEN_PAREN); + setState(5074); + match(WHERE); + setState(5075); + where_clause(); + setState(5076); + match(CLOSE_PAREN); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5080); + identifier(0); + setState(5081); + match(OPEN_PAREN); + setState(5090); + _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)) & -3051208608109821955L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 4537576733544546303L) != 0) || ((((_la - 787)) & ~0x3f) == 0 && ((1L << (_la - 787)) & 1262854602757L) != 0)) { + { + setState(5082); + expr(0); + setState(5087); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5083); + match(COMMA); + setState(5084); + expr(0); + } + } + setState(5089); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(5092); + match(CLOSE_PAREN); + setState(5093); + match(WITHIN); + setState(5094); + match(GROUP); + setState(5095); + match(OPEN_PAREN); + setState(5096); + order_by_clause(); + setState(5097); + match(CLOSE_PAREN); + setState(5104); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,604,_ctx) ) { + case 1: + { + setState(5098); + match(FILTER); + setState(5099); + match(OPEN_PAREN); + setState(5100); + match(WHERE); + setState(5101); + where_clause(); + setState(5102); + 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 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 Name_Context(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_name_; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterName_(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitName_(this); + } + } + + public final Name_Context name_() throws RecognitionException { + Name_Context _localctx = new Name_Context(_ctx, getState()); + enterRule(_localctx, 460, RULE_name_); + try { + setState(5110); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SINGLEQ_STRING_LITERAL: + enterOuterAlt(_localctx, 1); + { + setState(5108); + match(SINGLEQ_STRING_LITERAL); + } + 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_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 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(5109); + 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 Name_listContext extends ParserRuleContext { + public List name_() { + return getRuleContexts(Name_Context.class); + } + public Name_Context name_(int i) { + return getRuleContext(Name_Context.class,i); + } + public List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Name_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_name_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterName_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitName_list(this); + } + } + + public final Name_listContext name_list() throws RecognitionException { + Name_listContext _localctx = new Name_listContext(_ctx, getState()); + enterRule(_localctx, 462, RULE_name_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5112); + name_(); + setState(5117); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5113); + match(COMMA); + setState(5114); + name_(); + } + } + setState(5119); + _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 Identifier_listContext extends ParserRuleContext { + 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 Identifier_listContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_identifier_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterIdentifier_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitIdentifier_list(this); + } + } + + public final Identifier_listContext identifier_list() throws RecognitionException { + Identifier_listContext _localctx = new Identifier_listContext(_ctx, getState()); + enterRule(_localctx, 464, RULE_identifier_list); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(5120); + identifier(0); + setState(5125); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,608,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(5121); + match(COMMA); + setState(5122); + identifier(0); + } + } + } + setState(5127); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,608,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_option_expr; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOption_expr(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOption_expr(this); + } + } + + public final Option_exprContext option_expr() throws RecognitionException { + Option_exprContext _localctx = new Option_exprContext(_ctx, getState()); + enterRule(_localctx, 466, RULE_option_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5128); + ((Option_exprContext)_localctx).option_name = identifier(0); + setState(5131); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQUAL) { + { + setState(5129); + match(EQUAL); + setState(5130); + ((Option_exprContext)_localctx).value = param_value(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Option_listContext extends ParserRuleContext { + public List option_expr() { + return getRuleContexts(Option_exprContext.class); + } + 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_option_list; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterOption_list(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitOption_list(this); + } + } + + public final Option_listContext option_list() throws RecognitionException { + Option_listContext _localctx = new Option_listContext(_ctx, getState()); + enterRule(_localctx, 468, RULE_option_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5133); + option_expr(); + setState(5138); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5134); + match(COMMA); + setState(5135); + option_expr(); + } + } + setState(5140); + _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, 470, RULE_table_name_); + try { + enterOuterAlt(_localctx, 1); + { + setState(5141); + 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, 472, RULE_data_type); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(5145); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,611,_ctx) ) { + case 1: + { + setState(5143); + type_name(); + } + break; + case 2: + { + setState(5144); + identifier(0); + } + break; + } + setState(5154); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,613,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(5147); + match(OPEN_BRACKET); + setState(5149); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INTEGER_LITERAL) { + { + setState(5148); + match(INTEGER_LITERAL); + } + } + + setState(5151); + match(CLOSE_BRACKET); + } + } + } + setState(5156); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,613,_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, 474, RULE_data_type_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5157); + data_type(); + setState(5162); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5158); + match(COMMA); + setState(5159); + data_type(); + } + } + setState(5164); + _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, 476, RULE_index_method); + int _la; + try { + setState(5167); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BTREE: + case HASH_: + case GIST: + case SPGIST: + case GIN: + case BRIN: + enterOuterAlt(_localctx, 1); + { + setState(5165); + ((Index_methodContext)_localctx).builtin = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 702)) & ~0x3f) == 0 && ((1L << (_la - 702)) & 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_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 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(5166); + ((Index_methodContext)_localctx).unknown = 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 Func_nameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Func_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_name(this); + } + } + + public final Func_nameContext func_name() throws RecognitionException { + Func_nameContext _localctx = new Func_nameContext(_ctx, getState()); + enterRule(_localctx, 478, RULE_func_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(5169); + 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 Func_callContext 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 VARIADIC() { return getToken(PostgreSqlParser.VARIADIC, 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 List COMMA() { return getTokens(PostgreSqlParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(PostgreSqlParser.COMMA, i); + } + public Todo_fill_inContext todo_fill_in() { + return getRuleContext(Todo_fill_inContext.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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_func_call; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterFunc_call(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitFunc_call(this); + } + } + + public final Func_callContext func_call() throws RecognitionException { + Func_callContext _localctx = new Func_callContext(_ctx, getState()); + enterRule(_localctx, 480, RULE_func_call); + int _la; + try { + int _alt; + setState(5207); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,620,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5171); + func_name(); + setState(5172); + match(OPEN_PAREN); + setState(5173); + match(VARIADIC); + setState(5174); + expr(0); + setState(5175); + match(CLOSE_PAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5177); + func_name(); + setState(5178); + match(OPEN_PAREN); + setState(5192); + _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)) & -3051208608109821955L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 4537576733544546303L) != 0) || ((((_la - 787)) & ~0x3f) == 0 && ((1L << (_la - 787)) & 1262854602757L) != 0)) { + { + setState(5179); + expr(0); + setState(5184); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,616,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(5180); + match(COMMA); + setState(5181); + expr(0); + } + } + } + setState(5186); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,616,_ctx); + } + setState(5190); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(5187); + match(COMMA); + setState(5188); + match(VARIADIC); + setState(5189); + expr(0); + } + } + + } + } + + setState(5194); + match(CLOSE_PAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5196); + func_name(); + setState(5197); + match(OPEN_PAREN); + setState(5198); + todo_fill_in(); + setState(5199); + match(FROM); + setState(5200); + expr(0); + setState(5203); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR) { + { + setState(5201); + match(FOR); + setState(5202); + expr(0); + } + } + + setState(5205); + 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, 482, RULE_array_cons_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5209); + match(ARRAY); + setState(5210); + match(OPEN_BRACKET); + setState(5219); + _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)) & -3051208608109821955L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || ((((_la - 720)) & ~0x3f) == 0 && ((1L << (_la - 720)) & 4537576733544546303L) != 0) || ((((_la - 787)) & ~0x3f) == 0 && ((1L << (_la - 787)) & 1262854602757L) != 0)) { + { + setState(5211); + expr(0); + setState(5216); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5212); + match(COMMA); + setState(5213); + expr(0); + } + } + setState(5218); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(5221); + 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 = 484; + enterRecursionRule(_localctx, 484, RULE_from_item, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(5329); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,641,_ctx) ) { + case 1: + { + setState(5225); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ONLY) { + { + setState(5224); + match(ONLY); + } + } + + setState(5227); + table_name_(); + setState(5229); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,624,_ctx) ) { + case 1: + { + setState(5228); + match(STAR); + } + break; + } + setState(5232); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,625,_ctx) ) { + case 1: + { + setState(5231); + with_column_alias(); + } + break; + } + setState(5253); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,628,_ctx) ) { + case 1: + { + setState(5234); + match(TABLESAMPLE); + setState(5235); + todo_fill_in(); + setState(5236); + match(OPEN_PAREN); + setState(5237); + expr(0); + setState(5242); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5238); + match(COMMA); + setState(5239); + expr(0); + } + } + setState(5244); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5245); + match(CLOSE_PAREN); + setState(5251); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,627,_ctx) ) { + case 1: + { + setState(5246); + match(REPEATABLE); + setState(5247); + match(OPEN_PAREN); + setState(5248); + todo_fill_in(); + setState(5249); + match(CLOSE_PAREN); + } + break; + } + } + break; + } + } + break; + case 2: + { + setState(5256); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LATERAL) { + { + setState(5255); + match(LATERAL); + } + } + + setState(5258); + match(OPEN_PAREN); + setState(5259); + stmt(); + setState(5260); + match(CLOSE_PAREN); + setState(5262); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(5261); + match(AS); + } + } + + setState(5264); + alias(); + setState(5276); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,632,_ctx) ) { + case 1: + { + setState(5265); + match(OPEN_PAREN); + setState(5266); + column_alias(); + setState(5271); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5267); + match(COMMA); + setState(5268); + column_alias(); + } + } + setState(5273); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5274); + match(CLOSE_PAREN); + } + break; + } + } + break; + case 3: + { + setState(5279); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LATERAL) { + { + setState(5278); + match(LATERAL); + } + } + + setState(5281); + func_call(); + setState(5284); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,634,_ctx) ) { + case 1: + { + setState(5282); + match(WITH); + setState(5283); + match(ORDINALITY); + } + break; + } + setState(5287); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,635,_ctx) ) { + case 1: + { + setState(5286); + with_column_alias(); + } + break; + } + } + break; + case 4: + { + setState(5290); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LATERAL) { + { + setState(5289); + match(LATERAL); + } + } + + setState(5292); + func_call(); + setState(5293); + match(AS); + setState(5294); + match(OPEN_PAREN); + setState(5295); + column_definition(); + setState(5300); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5296); + match(COMMA); + setState(5297); + column_definition(); + } + } + setState(5302); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5303); + match(CLOSE_PAREN); + } + break; + case 5: + { + setState(5306); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LATERAL) { + { + setState(5305); + match(LATERAL); + } + } + + setState(5308); + match(ROWS); + setState(5309); + match(FROM); + setState(5310); + match(OPEN_PAREN); + setState(5311); + func_call(); + setState(5312); + match(CLOSE_PAREN); + setState(5325); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(5313); + match(AS); + setState(5314); + match(OPEN_PAREN); + setState(5315); + column_definition(); + setState(5320); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5316); + match(COMMA); + setState(5317); + column_definition(); + } + } + setState(5322); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5323); + match(CLOSE_PAREN); + } + } + + setState(5327); + match(CLOSE_PAREN); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(5348); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,646,_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(5331); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(5333); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NATURAL) { + { + setState(5332); + match(NATURAL); + } + } + + setState(5335); + join_type(); + setState(5337); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,643,_ctx) ) { + case 1: + { + setState(5336); + match(OPEN_PAREN); + } + break; + } + setState(5339); + from_item(0); + setState(5341); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,644,_ctx) ) { + case 1: + { + setState(5340); + join_clause(); + } + break; + } + setState(5344); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,645,_ctx) ) { + case 1: + { + setState(5343); + match(CLOSE_PAREN); + } + break; + } + } + } + } + setState(5350); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,646,_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, 486, RULE_with_column_alias); + int _la; + try { + int _alt; + setState(5373); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,651,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5352); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(5351); + match(AS); + } + } + + setState(5354); + alias(); + setState(5363); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,649,_ctx) ) { + case 1: + { + setState(5355); + column_alias(); + setState(5360); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,648,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(5356); + match(COMMA); + setState(5357); + column_alias(); + } + } + } + setState(5362); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,648,_ctx); + } + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5366); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(5365); + match(AS); + } + } + + setState(5368); + alias(); + setState(5369); + match(OPEN_PAREN); + setState(5370); + name_list(); + setState(5371); + 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, 488, RULE_join_type); + int _la; + try { + setState(5396); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INNER: + case JOIN: + enterOuterAlt(_localctx, 1); + { + setState(5376); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INNER) { + { + setState(5375); + match(INNER); + } + } + + setState(5378); + match(JOIN); + } + break; + case LEFT: + enterOuterAlt(_localctx, 2); + { + setState(5379); + match(LEFT); + setState(5381); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OUTER) { + { + setState(5380); + match(OUTER); + } + } + + setState(5383); + match(JOIN); + } + break; + case RIGHT: + enterOuterAlt(_localctx, 3); + { + setState(5384); + match(RIGHT); + setState(5386); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OUTER) { + { + setState(5385); + match(OUTER); + } + } + + setState(5388); + match(JOIN); + } + break; + case FULL: + enterOuterAlt(_localctx, 4); + { + setState(5389); + match(FULL); + setState(5391); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OUTER) { + { + setState(5390); + match(OUTER); + } + } + + setState(5393); + match(JOIN); + } + break; + case CROSS: + enterOuterAlt(_localctx, 5); + { + setState(5394); + match(CROSS); + setState(5395); + 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, 490, RULE_join_clause); + int _la; + try { + setState(5412); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ON: + enterOuterAlt(_localctx, 1); + { + setState(5398); + match(ON); + setState(5399); + predicate(0); + } + break; + case USING: + enterOuterAlt(_localctx, 2); + { + setState(5400); + match(USING); + setState(5401); + match(OPEN_PAREN); + setState(5402); + column_name(); + setState(5407); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5403); + match(COMMA); + setState(5404); + column_name(); + } + } + setState(5409); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(5410); + 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 = 492; + enterRecursionRule(_localctx, 492, RULE_predicate, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(5426); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,659,_ctx) ) { + case 1: + { + setState(5415); + expr(0); + } + break; + case 2: + { + setState(5416); + expr(0); + setState(5417); + oper(); + setState(5418); + expr(0); + } + break; + case 3: + { + setState(5420); + match(OPEN_PAREN); + setState(5421); + predicate(0); + setState(5422); + match(CLOSE_PAREN); + } + break; + case 4: + { + setState(5424); + match(NOT); + setState(5425); + predicate(1); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(5436); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,661,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(5434); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,660,_ctx) ) { + case 1: + { + _localctx = new PredicateContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(5428); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(5429); + match(AND); + setState(5430); + predicate(4); + } + break; + case 2: + { + _localctx = new PredicateContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_predicate); + setState(5431); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(5432); + match(OR); + setState(5433); + predicate(3); + } + break; + } + } + } + setState(5438); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,661,_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, 494, RULE_aggregate_signature); + int _la; + try { + setState(5465); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,668,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5439); + match(STAR); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5441); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN || _la==VARIADIC) { + { + setState(5440); + ((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(5444); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,663,_ctx) ) { + case 1: + { + setState(5443); + ((Aggregate_signatureContext)_localctx).argname = identifier(0); + } + break; + } + setState(5446); + ((Aggregate_signatureContext)_localctx).argtype = data_type_list(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + { + setState(5448); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN || _la==VARIADIC) { + { + setState(5447); + ((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(5451); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,665,_ctx) ) { + case 1: + { + setState(5450); + ((Aggregate_signatureContext)_localctx).argname = identifier(0); + } + break; + } + setState(5453); + ((Aggregate_signatureContext)_localctx).argtype = data_type_list(); + } + setState(5455); + match(ORDER); + setState(5456); + match(BY); + setState(5458); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IN || _la==VARIADIC) { + { + setState(5457); + ((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(5461); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,667,_ctx) ) { + case 1: + { + setState(5460); + ((Aggregate_signatureContext)_localctx).argname = identifier(0); + } + break; + } + setState(5463); + ((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, 496, RULE_column_constraint); + try { + enterOuterAlt(_localctx, 1); + { + setState(5467); + match(NOT); + setState(5468); + 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, 498, RULE_column_constraints); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5471); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(5470); + column_constraint(); + } + } + setState(5473); + _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, 500, RULE_index_parameters); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5480); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==WITH) { + { + setState(5475); + match(WITH); + setState(5476); + match(OPEN_PAREN); + setState(5477); + option_list(); + setState(5478); + match(CLOSE_PAREN); + } + } + + setState(5486); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(5482); + match(USING); + setState(5483); + match(INDEX); + setState(5484); + match(TABLESPACE); + setState(5485); + ((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, 502, RULE_exclude_element); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5493); + _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_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 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(5488); + ((Exclude_elementContext)_localctx).column_name_ = identifier(0); + } + break; + case OPEN_PAREN: + { + setState(5489); + match(OPEN_PAREN); + setState(5490); + expr(0); + setState(5491); + match(CLOSE_PAREN); + } + break; + default: + throw new NoViableAltException(this); + } + setState(5496); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,673,_ctx) ) { + case 1: + { + setState(5495); + ((Exclude_elementContext)_localctx).opclass = identifier(0); + } + break; + } + setState(5499); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASC || _la==DESC) { + { + setState(5498); + _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(5503); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NULLS) { + { + setState(5501); + match(NULLS); + setState(5502); + _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, 504, RULE_table_constraint); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5507); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==CONSTRAINT) { + { + setState(5505); + match(CONSTRAINT); + setState(5506); + ((Table_constraintContext)_localctx).constraint_name = name_(); + } + } + + setState(5574); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CHECK: + { + { + setState(5509); + match(CHECK); + setState(5510); + match(OPEN_PAREN); + setState(5511); + expr(0); + setState(5512); + match(CLOSE_PAREN); + setState(5515); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NO) { + { + setState(5513); + match(NO); + setState(5514); + match(INHERIT); + } + } + + } + } + break; + case UNIQUE: + { + { + setState(5517); + match(UNIQUE); + setState(5518); + match(OPEN_PAREN); + setState(5519); + ((Table_constraintContext)_localctx).columns = identifier_list(); + setState(5520); + match(CLOSE_PAREN); + } + } + break; + case PRIMARY: + { + { + setState(5522); + match(PRIMARY); + setState(5523); + match(KEY); + setState(5524); + match(OPEN_PAREN); + setState(5525); + ((Table_constraintContext)_localctx).columns = identifier_list(); + setState(5526); + match(CLOSE_PAREN); + setState(5527); + index_parameters(); + } + } + break; + case EOF: + case DEFERABLE: + case EXCLUDE: + case INITIALLY: + case NOT: + case COMMA: + case CLOSE_PAREN: + case SEMI: + { + setState(5545); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXCLUDE) { + { + setState(5529); + match(EXCLUDE); + setState(5532); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==USING) { + { + setState(5530); + match(USING); + setState(5531); + index_method(); + } + } + + setState(5534); + match(OPEN_PAREN); + setState(5535); + exclude_element(); + setState(5536); + match(WITH); + setState(5537); + ((Table_constraintContext)_localctx).operators = identifier_list(); + setState(5538); + match(CLOSE_PAREN); + setState(5539); + index_parameters(); + { + setState(5540); + match(WHERE); + setState(5541); + match(OPEN_PAREN); + setState(5542); + predicate(0); + setState(5543); + match(CLOSE_PAREN); + } + } + } + + } + break; + case FOREIGN: + { + { + setState(5547); + match(FOREIGN); + setState(5548); + match(KEY); + setState(5549); + match(OPEN_PAREN); + setState(5550); + ((Table_constraintContext)_localctx).columns = identifier_list(); + setState(5551); + match(CLOSE_PAREN); + setState(5552); + match(REFERENCES); + setState(5553); + ((Table_constraintContext)_localctx).reftable = identifier(0); + setState(5555); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,680,_ctx) ) { + case 1: + { + setState(5554); + ((Table_constraintContext)_localctx).columns = identifier_list(); + } + break; + } + setState(5562); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,681,_ctx) ) { + case 1: + { + setState(5557); + match(MATCH); + setState(5558); + match(FULL); + } + break; + case 2: + { + setState(5559); + match(MATCH); + setState(5560); + match(PARTIAL); + } + break; + case 3: + { + setState(5561); + match(MATCH_SIMPLE); + } + break; + } + setState(5567); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,682,_ctx) ) { + case 1: + { + setState(5564); + match(ON); + setState(5565); + match(DELETE); + setState(5566); + ((Table_constraintContext)_localctx).action = identifier(0); + } + break; + } + setState(5572); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ON) { + { + setState(5569); + match(ON); + setState(5570); + match(UPDATE); + setState(5571); + ((Table_constraintContext)_localctx).action = identifier(0); + } + } + + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(5580); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,686,_ctx) ) { + case 1: + { + setState(5577); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NOT) { + { + setState(5576); + match(NOT); + } + } + + setState(5579); + match(DEFERABLE); + } + break; + } + setState(5584); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==INITIALLY) { + { + setState(5582); + match(INITIALLY); + setState(5583); + _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, 506, RULE_role_name); + try { + setState(5590); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,688,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5586); + ((Role_nameContext)_localctx).name = name_(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5587); + match(CURRENT_USER); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5588); + match(SESSION_USER); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5589); + 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, 508, RULE_role_name_list); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5592); + role_name(); + setState(5597); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(5593); + match(COMMA); + setState(5594); + role_name(); + } + } + setState(5599); + _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 TerminalNode NUMERIC_LITERAL() { return getToken(PostgreSqlParser.NUMERIC_LITERAL, 0); } + public TerminalNode INTEGER_LITERAL() { return getToken(PostgreSqlParser.INTEGER_LITERAL, 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, 510, RULE_param_value); + try { + setState(5611); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,690,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(5600); + match(ON); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(5601); + match(OFF); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(5602); + match(TRUE); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(5603); + match(FALSE); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(5604); + match(YES); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(5605); + match(NO); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(5606); + match(NONE); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(5607); + match(SINGLEQ_STRING_LITERAL); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(5608); + match(NUMERIC_LITERAL); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(5609); + match(INTEGER_LITERAL); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(5610); + 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 Non_reserved_keywordContext extends ParserRuleContext { + public TerminalNode A_() { return getToken(PostgreSqlParser.A_, 0); } + public TerminalNode ABORT() { return getToken(PostgreSqlParser.ABORT, 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 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 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 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 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 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 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 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 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_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 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 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) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_non_reserved_keyword; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterNon_reserved_keyword(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitNon_reserved_keyword(this); + } + } + + public final Non_reserved_keywordContext non_reserved_keyword() throws RecognitionException { + Non_reserved_keywordContext _localctx = new Non_reserved_keywordContext(_ctx, getState()); + enterRule(_localctx, 512, RULE_non_reserved_keyword); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(5613); + _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)) & -7662894626537209859L) != 0) || ((((_la - 649)) & ~0x3f) == 0 && ((1L << (_la - 649)) & 87L) != 0) || _la==TEXT) ) { + _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 IdentifierContext extends ParserRuleContext { + public Non_reserved_keywordContext non_reserved_keyword() { + return getRuleContext(Non_reserved_keywordContext.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 TerminalNode IDENTIFIER_UNICODE() { return getToken(PostgreSqlParser.IDENTIFIER_UNICODE, 0); } + public List identifier() { + return getRuleContexts(IdentifierContext.class); + } + public IdentifierContext identifier(int i) { + return getRuleContext(IdentifierContext.class,i); + } + public TerminalNode DOT() { return getToken(PostgreSqlParser.DOT, 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 { + return identifier(0); + } + + private IdentifierContext identifier(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + IdentifierContext _localctx = new IdentifierContext(_ctx, _parentState); + IdentifierContext _prevctx = _localctx; + int _startState = 514; + enterRecursionRule(_localctx, 514, RULE_identifier, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(5621); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,691,_ctx) ) { + case 1: + { + setState(5616); + non_reserved_keyword(); + } + break; + case 2: + { + setState(5617); + match(DOUBLEQ_STRING_LITERAL); + } + break; + case 3: + { + setState(5618); + match(IDENTIFIER); + } + break; + case 4: + { + setState(5619); + type_name(); + } + break; + case 5: + { + setState(5620); + match(IDENTIFIER_UNICODE); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(5628); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,692,_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(5623); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(5624); + match(DOT); + setState(5625); + identifier(4); + } + } + } + setState(5630); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,692,_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, 516, RULE_todo_fill_in); + try { + enterOuterAlt(_localctx, 1); + { + setState(5631); + matchWildcard(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + @SuppressWarnings("CheckReturnValue") + public static class Todo_implementContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Todo_implementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_todo_implement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterTodo_implement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitTodo_implement(this); + } + } + + public final Todo_implementContext todo_implement() throws RecognitionException { + Todo_implementContext _localctx = new Todo_implementContext(_ctx, getState()); + enterRule(_localctx, 518, RULE_todo_implement); + try { + enterOuterAlt(_localctx, 1); + { + setState(5633); + 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 Correlation_nameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Correlation_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_correlation_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterCorrelation_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitCorrelation_name(this); + } + } + + public final Correlation_nameContext correlation_name() throws RecognitionException { + Correlation_nameContext _localctx = new Correlation_nameContext(_ctx, getState()); + enterRule(_localctx, 520, RULE_correlation_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(5635); + 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 Column_nameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Column_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_column_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_name(this); + } + } + + public final Column_nameContext column_name() throws RecognitionException { + Column_nameContext _localctx = new Column_nameContext(_ctx, getState()); + enterRule(_localctx, 522, RULE_column_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(5637); + 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 AliasContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public AliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alias; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterAlias(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitAlias(this); + } + } + + public final AliasContext alias() throws RecognitionException { + AliasContext _localctx = new AliasContext(_ctx, getState()); + enterRule(_localctx, 524, RULE_alias); + try { + enterOuterAlt(_localctx, 1); + { + setState(5639); + 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 Column_aliasContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Column_aliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_column_alias; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_alias(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_alias(this); + } + } + + public final Column_aliasContext column_alias() throws RecognitionException { + Column_aliasContext _localctx = new Column_aliasContext(_ctx, getState()); + enterRule(_localctx, 526, RULE_column_alias); + try { + enterOuterAlt(_localctx, 1); + { + setState(5641); + 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 Column_definitionContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Column_definitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_column_definition; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterColumn_definition(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitColumn_definition(this); + } + } + + public final Column_definitionContext column_definition() throws RecognitionException { + Column_definitionContext _localctx = new Column_definitionContext(_ctx, getState()); + enterRule(_localctx, 528, RULE_column_definition); + try { + enterOuterAlt(_localctx, 1); + { + setState(5643); + 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 Window_nameContext extends ParserRuleContext { + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class,0); + } + public Window_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_window_name; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).enterWindow_name(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof PostgreSqlParserListener ) ((PostgreSqlParserListener)listener).exitWindow_name(this); + } + } + + public final Window_nameContext window_name() throws RecognitionException { + Window_nameContext _localctx = new Window_nameContext(_ctx, getState()); + enterRule(_localctx, 530, RULE_window_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(5645); + identifier(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 216: + return expr_sempred((ExprContext)_localctx, predIndex); + case 218: + return bool_expr_sempred((Bool_exprContext)_localctx, predIndex); + case 242: + return from_item_sempred((From_itemContext)_localctx, predIndex); + case 246: + return predicate_sempred((PredicateContext)_localctx, predIndex); + case 257: + return identifier_sempred((IdentifierContext)_localctx, predIndex); + } + return true; + } + private boolean expr_sempred(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: + return precpred(_ctx, 5); + } + return true; + } + private boolean bool_expr_sempred(Bool_exprContext _localctx, int predIndex) { + switch (predIndex) { + case 17: + return precpred(_ctx, 2); + case 18: + 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\u0344\u1610\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"+ + "\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+ + "\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+ + "\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+ + "\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007"+ + "\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007"+ + "\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007"+ + "\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007"+ + "\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007"+ + "\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007"+ + ",\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u0007"+ + "1\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u0007"+ + "6\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007"+ + ";\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007"+ + "@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007"+ + "E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007"+ + "J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007"+ + "O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007"+ + "T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007"+ + "Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007"+ + "^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007"+ + "c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007"+ + "h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007l\u0002m\u0007"+ + "m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007q\u0002r\u0007"+ + "r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007v\u0002w\u0007"+ + "w\u0002x\u0007x\u0002y\u0007y\u0002z\u0007z\u0002{\u0007{\u0002|\u0007"+ + "|\u0002}\u0007}\u0002~\u0007~\u0002\u007f\u0007\u007f\u0002\u0080\u0007"+ + "\u0080\u0002\u0081\u0007\u0081\u0002\u0082\u0007\u0082\u0002\u0083\u0007"+ + "\u0083\u0002\u0084\u0007\u0084\u0002\u0085\u0007\u0085\u0002\u0086\u0007"+ + "\u0086\u0002\u0087\u0007\u0087\u0002\u0088\u0007\u0088\u0002\u0089\u0007"+ + "\u0089\u0002\u008a\u0007\u008a\u0002\u008b\u0007\u008b\u0002\u008c\u0007"+ + "\u008c\u0002\u008d\u0007\u008d\u0002\u008e\u0007\u008e\u0002\u008f\u0007"+ + "\u008f\u0002\u0090\u0007\u0090\u0002\u0091\u0007\u0091\u0002\u0092\u0007"+ + "\u0092\u0002\u0093\u0007\u0093\u0002\u0094\u0007\u0094\u0002\u0095\u0007"+ + "\u0095\u0002\u0096\u0007\u0096\u0002\u0097\u0007\u0097\u0002\u0098\u0007"+ + "\u0098\u0002\u0099\u0007\u0099\u0002\u009a\u0007\u009a\u0002\u009b\u0007"+ + "\u009b\u0002\u009c\u0007\u009c\u0002\u009d\u0007\u009d\u0002\u009e\u0007"+ + "\u009e\u0002\u009f\u0007\u009f\u0002\u00a0\u0007\u00a0\u0002\u00a1\u0007"+ + "\u00a1\u0002\u00a2\u0007\u00a2\u0002\u00a3\u0007\u00a3\u0002\u00a4\u0007"+ + "\u00a4\u0002\u00a5\u0007\u00a5\u0002\u00a6\u0007\u00a6\u0002\u00a7\u0007"+ + "\u00a7\u0002\u00a8\u0007\u00a8\u0002\u00a9\u0007\u00a9\u0002\u00aa\u0007"+ + "\u00aa\u0002\u00ab\u0007\u00ab\u0002\u00ac\u0007\u00ac\u0002\u00ad\u0007"+ + "\u00ad\u0002\u00ae\u0007\u00ae\u0002\u00af\u0007\u00af\u0002\u00b0\u0007"+ + "\u00b0\u0002\u00b1\u0007\u00b1\u0002\u00b2\u0007\u00b2\u0002\u00b3\u0007"+ + "\u00b3\u0002\u00b4\u0007\u00b4\u0002\u00b5\u0007\u00b5\u0002\u00b6\u0007"+ + "\u00b6\u0002\u00b7\u0007\u00b7\u0002\u00b8\u0007\u00b8\u0002\u00b9\u0007"+ + "\u00b9\u0002\u00ba\u0007\u00ba\u0002\u00bb\u0007\u00bb\u0002\u00bc\u0007"+ + "\u00bc\u0002\u00bd\u0007\u00bd\u0002\u00be\u0007\u00be\u0002\u00bf\u0007"+ + "\u00bf\u0002\u00c0\u0007\u00c0\u0002\u00c1\u0007\u00c1\u0002\u00c2\u0007"+ + "\u00c2\u0002\u00c3\u0007\u00c3\u0002\u00c4\u0007\u00c4\u0002\u00c5\u0007"+ + "\u00c5\u0002\u00c6\u0007\u00c6\u0002\u00c7\u0007\u00c7\u0002\u00c8\u0007"+ + "\u00c8\u0002\u00c9\u0007\u00c9\u0002\u00ca\u0007\u00ca\u0002\u00cb\u0007"+ + "\u00cb\u0002\u00cc\u0007\u00cc\u0002\u00cd\u0007\u00cd\u0002\u00ce\u0007"+ + "\u00ce\u0002\u00cf\u0007\u00cf\u0002\u00d0\u0007\u00d0\u0002\u00d1\u0007"+ + "\u00d1\u0002\u00d2\u0007\u00d2\u0002\u00d3\u0007\u00d3\u0002\u00d4\u0007"+ + "\u00d4\u0002\u00d5\u0007\u00d5\u0002\u00d6\u0007\u00d6\u0002\u00d7\u0007"+ + "\u00d7\u0002\u00d8\u0007\u00d8\u0002\u00d9\u0007\u00d9\u0002\u00da\u0007"+ + "\u00da\u0002\u00db\u0007\u00db\u0002\u00dc\u0007\u00dc\u0002\u00dd\u0007"+ + "\u00dd\u0002\u00de\u0007\u00de\u0002\u00df\u0007\u00df\u0002\u00e0\u0007"+ + "\u00e0\u0002\u00e1\u0007\u00e1\u0002\u00e2\u0007\u00e2\u0002\u00e3\u0007"+ + "\u00e3\u0002\u00e4\u0007\u00e4\u0002\u00e5\u0007\u00e5\u0002\u00e6\u0007"+ + "\u00e6\u0002\u00e7\u0007\u00e7\u0002\u00e8\u0007\u00e8\u0002\u00e9\u0007"+ + "\u00e9\u0002\u00ea\u0007\u00ea\u0002\u00eb\u0007\u00eb\u0002\u00ec\u0007"+ + "\u00ec\u0002\u00ed\u0007\u00ed\u0002\u00ee\u0007\u00ee\u0002\u00ef\u0007"+ + "\u00ef\u0002\u00f0\u0007\u00f0\u0002\u00f1\u0007\u00f1\u0002\u00f2\u0007"+ + "\u00f2\u0002\u00f3\u0007\u00f3\u0002\u00f4\u0007\u00f4\u0002\u00f5\u0007"+ + "\u00f5\u0002\u00f6\u0007\u00f6\u0002\u00f7\u0007\u00f7\u0002\u00f8\u0007"+ + "\u00f8\u0002\u00f9\u0007\u00f9\u0002\u00fa\u0007\u00fa\u0002\u00fb\u0007"+ + "\u00fb\u0002\u00fc\u0007\u00fc\u0002\u00fd\u0007\u00fd\u0002\u00fe\u0007"+ + "\u00fe\u0002\u00ff\u0007\u00ff\u0002\u0100\u0007\u0100\u0002\u0101\u0007"+ + "\u0101\u0002\u0102\u0007\u0102\u0002\u0103\u0007\u0103\u0002\u0104\u0007"+ + "\u0104\u0002\u0105\u0007\u0105\u0002\u0106\u0007\u0106\u0002\u0107\u0007"+ + "\u0107\u0002\u0108\u0007\u0108\u0002\u0109\u0007\u0109\u0001\u0000\u0001"+ + "\u0000\u0001\u0000\u0004\u0000\u0218\b\u0000\u000b\u0000\f\u0000\u0219"+ + "\u0001\u0000\u0001\u0000\u0003\u0000\u021e\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\u0256\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\u0282\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\u02a2\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\u02bf\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\u02d6\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\u02e4"+ + "\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\u02f4\b\t\u0001\t\u0001"+ + "\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0003\t\u02fd\b\t\u0001\t\u0001"+ + "\t\u0003\t\u0301\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\u0328\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\u0336\b\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0003\n\u0341\b\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001"+ + "\n\u0001\n\u0001\n\u0003\n\u034b\b\n\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\u000b\u0001\u000b\u0003\u000b\u0353\b\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0003\u000b\u035c\b\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0003\r\u0362"+ + "\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u0368\b\r\u0001\r\u0003\r"+ + "\u036b\b\r\u0001\r\u0001\r\u0003\r\u036f\b\r\u0001\r\u0001\r\u0003\r\u0373"+ + "\b\r\u0001\r\u0001\r\u0003\r\u0377\b\r\u0001\r\u0001\r\u0003\r\u037b\b"+ + "\r\u0001\r\u0001\r\u0001\r\u0003\r\u0380\b\r\u0001\r\u0001\r\u0001\r\u0001"+ + "\r\u0003\r\u0386\b\r\u0001\r\u0001\r\u0003\r\u038a\b\r\u0001\r\u0001\r"+ + "\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u0393\b\r\u0001\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u039b\b\r\u0001\r\u0001\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03a4\b\r\u0001\r\u0001\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03ad\b\r\u0001\r\u0001\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03b7\b\r\u0001\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03c1\b\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003\r\u03ca\b\r\u0001"+ + "\r\u0001\r\u0001\r\u0003\r\u03cf\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003"+ + "\r\u03d5\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001\r\u0003"+ + "\r\u03de\b\r\u0001\r\u0001\r\u0003\r\u03e2\b\r\u0001\r\u0001\r\u0001\r"+ + "\u0001\r\u0001\r\u0003\r\u03e9\b\r\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ + "\r\u0003\r\u03f0\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\u040a\b\r\u0003\r\u040c\b\r\u0001\u000e\u0001\u000e\u0001\u000e\u0005"+ + "\u000e\u0411\b\u000e\n\u000e\f\u000e\u0414\t\u000e\u0001\u000f\u0001\u000f"+ + "\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u041b\b\u000f\u0001\u000f"+ + "\u0003\u000f\u041e\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0422\b"+ + "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u000f\u0001\u000f\u0003\u000f\u042b\b\u000f\u0001\u000f\u0003\u000f\u042e"+ + "\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0432\b\u000f\u0001\u000f"+ + "\u0001\u000f\u0003\u000f\u0436\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0003\u000f\u0441\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0003\u000f\u044d\b\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f"+ + "\u0001\u000f\u0003\u000f\u0454\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\u046d\b\u0011\u0001\u0012\u0001\u0012"+ + "\u0001\u0012\u0001\u0012\u0003\u0012\u0473\b\u0012\u0001\u0012\u0001\u0012"+ + "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+ + "\u0001\u0012\u0003\u0012\u047e\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\u0491\b\u0012\u0001\u0012\u0001\u0012"+ + "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+ + "\u0001\u0012\u0001\u0012\u0003\u0012\u049d\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\u04ad\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012"+ + "\u0003\u0012\u04b3\b\u0012\u0003\u0012\u04b5\b\u0012\u0001\u0013\u0001"+ + "\u0013\u0003\u0013\u04b9\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u04c3"+ + "\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0003\u0013\u04cc\b\u0013\u0003\u0013\u04ce\b\u0013"+ + "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ + "\u0001\u0014\u0001\u0014\u0001\u0014\u0003\u0014\u04d9\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\u04f4\b\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ + "\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017"+ + "\u0003\u0017\u0500\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\u0514\b\u0019\u0001\u0019\u0001\u0019"+ + "\u0003\u0019\u0518\b\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019"+ + "\u051d\b\u0019\u0003\u0019\u051f\b\u0019\u0001\u001a\u0001\u001a\u0001"+ + "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003\u001a\u0527\b\u001a\u0001"+ + "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ + "\u001a\u0001\u001a\u0003\u001a\u0531\b\u001a\u0001\u001a\u0001\u001a\u0001"+ + "\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0003"+ + "\u001a\u053b\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\u0555\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\u0569\b\u001b\u0001"+ + "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0003\u001b\u0570"+ + "\b\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u0576"+ + "\b\u001c\u0001\u001c\u0004\u001c\u0579\b\u001c\u000b\u001c\f\u001c\u057a"+ + "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c"+ + "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c"+ + "\u0588\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u058d\b"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003"+ + "\u001c\u0594\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003"+ + "\u001c\u059a\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u059f"+ + "\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u05aa\b\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u05af\b\u001c\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u05b7"+ + "\b\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c\u05bc\b\u001c"+ + "\u0001\u001c\u0001\u001c\u0003\u001c\u05c0\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\u05da\b\u001e"+ + "\u0003\u001e\u05dc\b\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+ + "\u0003\u001f\u05e2\b\u001f\u0001\u001f\u0001\u001f\u0001 \u0003 \u05e7"+ + "\b \u0001 \u0001 \u0003 \u05eb\b \u0001 \u0001 \u0003 \u05ef\b \u0001"+ + " \u0001 \u0003 \u05f3\b \u0005 \u05f5\b \n \f \u05f8\t \u0001!\u0001!"+ + "\u0001!\u0001!\u0001!\u0001!\u0001!\u0003!\u0601\b!\u0001!\u0001!\u0001"+ + "!\u0001!\u0001!\u0003!\u0608\b!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001"+ + "!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001!\u0003!\u0618"+ + "\b!\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0003"+ + "\"\u0622\b\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+ + "\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0001\"\u0003\"\u0632\b\"\u0001"+ + "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ + "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0003#\u0645\b#\u0001#\u0001"+ + "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0003#\u0651"+ + "\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#\u0673\b#\u0001$\u0001$\u0001$\u0001$\u0001$\u0001"+ + "$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0003$\u0683"+ + "\b$\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ + "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0003&\u0696\b&\u0001"+ + "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ + "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0003&\u06a8\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\'\u06e5\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\'\u0705"+ + "\b\'\u0001(\u0001(\u0001)\u0001)\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ + "*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001"+ + "*\u0001*\u0001*\u0003*\u071d\b*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001"+ + "+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001"+ + "+\u0001+\u0001+\u0001+\u0003+\u0732\b+\u0001,\u0001,\u0001-\u0001-\u0001"+ + ".\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001.\u0001"+ + ".\u0001.\u0001/\u0001/\u00010\u00010\u00030\u0748\b0\u00010\u00010\u0001"+ + "0\u00010\u00010\u00030\u074f\b0\u00011\u00011\u00012\u00012\u00013\u0001"+ + "3\u00014\u00014\u00015\u00015\u00016\u00016\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\u00017\u00017\u00017\u00017\u00017\u00037\u0784\b7\u00018\u00018\u0001"+ + "8\u00018\u00018\u00018\u00018\u00018\u00018\u00019\u00019\u00019\u0001"+ + "9\u00019\u00039\u0794\b9\u00019\u00039\u0797\b9\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ + "9\u00039\u07a7\b9\u00019\u00019\u00019\u00019\u00039\u07ad\b9\u00019\u0001"+ + "9\u00039\u07b1\b9\u00019\u00019\u00019\u00019\u00039\u07b7\b9\u00019\u0001"+ + "9\u00019\u00019\u00039\u07bd\b9\u00019\u00019\u00019\u00019\u00039\u07c3"+ + "\b9\u00019\u00019\u00019\u00019\u00039\u07c9\b9\u00019\u00019\u00019\u0001"+ + "9\u00039\u07cf\b9\u00019\u00019\u00019\u00019\u00039\u07d5\b9\u00019\u0001"+ + "9\u00019\u00019\u00039\u07db\b9\u00019\u00019\u00019\u00019\u00039\u07e1"+ + "\b9\u00019\u00019\u00019\u00019\u00039\u07e7\b9\u00019\u00019\u00039\u07eb"+ + "\b9\u00019\u00019\u00019\u00019\u00039\u07f1\b9\u00019\u00019\u00019\u0001"+ + "9\u00039\u07f7\b9\u00019\u00019\u00019\u00019\u00039\u07fd\b9\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00039\u0806\b9\u00019\u00039\u0809"+ + "\b9\u00019\u00039\u080c\b9\u00019\u00019\u00019\u00039\u0811\b9\u0001"+ + "9\u00039\u0814\b9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00039\u0824\b9\u00019\u0001"+ + "9\u00019\u00019\u00039\u082a\b9\u00019\u00019\u00039\u082e\b9\u00019\u0001"+ + "9\u00019\u00019\u00039\u0834\b9\u00019\u00019\u00019\u00019\u00039\u083a"+ + "\b9\u00019\u00019\u00039\u083e\b9\u00019\u00019\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ + "9\u00019\u00019\u00019\u00019\u00019\u00039\u0855\b9\u00019\u00019\u0001"+ + "9\u00019\u00039\u085b\b9\u00019\u00019\u00039\u085f\b9\u00019\u00019\u0001"+ + "9\u00019\u00039\u0865\b9\u00019\u00019\u00019\u00019\u00039\u086b\b9\u0001"+ + "9\u00019\u00019\u00019\u00039\u0871\b9\u00019\u00019\u00019\u00019\u0003"+ + "9\u0877\b9\u00019\u00019\u00019\u00019\u00039\u087d\b9\u00019\u00019\u0001"+ + "9\u00019\u00039\u0883\b9\u00019\u00019\u00019\u00019\u00039\u0889\b9\u0001"+ + "9\u00019\u00019\u00019\u00039\u088f\b9\u00019\u00019\u00019\u00019\u0003"+ + "9\u0895\b9\u00019\u00019\u00039\u0899\b9\u00019\u00019\u00019\u00019\u0003"+ + "9\u089f\b9\u00019\u00019\u00019\u00019\u00039\u08a5\b9\u00019\u00019\u0003"+ + "9\u08a9\b9\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001:\u0001"+ + ":\u0001:\u0001:\u0001:\u0001:\u0001:\u0003:\u08b9\b:\u0001:\u0001:\u0001"+ + ":\u0001:\u0003:\u08bf\b:\u0001:\u0001:\u0001:\u0001:\u0003:\u08c5\b:\u0001"+ + ";\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001"+ + ";\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0001;\u0003;\u08d9\b;\u0001"+ + "<\u0001<\u0001<\u0005<\u08de\b<\n<\f<\u08e1\t<\u0001=\u0001=\u0001=\u0001"+ + "=\u0001=\u0003=\u08e8\b=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001"+ + "=\u0001=\u0001=\u0001=\u0003=\u08f4\b=\u0001=\u0001=\u0001=\u0001=\u0003"+ + "=\u08fa\b=\u0001>\u0001>\u0003>\u08fe\b>\u0001>\u0001>\u0001>\u0001>\u0001"+ + ">\u0001>\u0001>\u0001>\u0001>\u0001?\u0001?\u0001?\u0001?\u0003?\u090d"+ + "\b?\u0001?\u0001?\u0001?\u0003?\u0912\b?\u0001?\u0001?\u0001?\u0003?\u0917"+ + "\b?\u0001?\u0001?\u0001?\u0003?\u091c\b?\u0001?\u0001?\u0001?\u0003?\u0921"+ + "\b?\u0001?\u0001?\u0001?\u0003?\u0926\b?\u0001?\u0001?\u0001?\u0003?\u092b"+ + "\b?\u0001?\u0001?\u0001?\u0003?\u0930\b?\u0001?\u0001?\u0001?\u0001?\u0003"+ + "?\u0936\b?\u0001?\u0001?\u0001?\u0003?\u093b\b?\u0001@\u0001@\u0003@\u093f"+ + "\b@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0003@\u0949"+ + "\b@\u0001A\u0001A\u0001A\u0001A\u0003A\u094f\bA\u0001A\u0001A\u0001A\u0001"+ + "A\u0001A\u0001A\u0005A\u0957\bA\nA\fA\u095a\tA\u0001B\u0001B\u0001B\u0001"+ + "B\u0001B\u0001B\u0005B\u0962\bB\nB\fB\u0965\tB\u0001B\u0001B\u0001B\u0005"+ + "B\u096a\bB\nB\fB\u096d\tB\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+ + "C\u0001C\u0003C\u0977\bC\u0001C\u0001C\u0001C\u0001C\u0001C\u0001C\u0001"+ + "D\u0001D\u0001D\u0001D\u0005D\u0983\bD\nD\fD\u0986\tD\u0001E\u0001E\u0001"+ + "E\u0001E\u0001E\u0001E\u0001E\u0001E\u0001E\u0005E\u0991\bE\nE\fE\u0994"+ + "\tE\u0001E\u0001E\u0001E\u0001E\u0003E\u099a\bE\u0001E\u0001E\u0001E\u0001"+ + "E\u0001E\u0003E\u09a1\bE\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003"+ + "F\u09a9\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+ + "F\u0003F\u09b4\bF\u0001F\u0001F\u0003F\u09b8\bF\u0001F\u0001F\u0001F\u0003"+ + "F\u09bd\bF\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0003F\u09c6"+ + "\bF\u0001G\u0001G\u0001G\u0003G\u09cb\bG\u0001G\u0001G\u0001G\u0001H\u0001"+ + "H\u0001H\u0001H\u0003H\u09d4\bH\u0001H\u0001H\u0001H\u0001H\u0001H\u0001"+ + "H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0003H\u09e3\bH\u0001"+ + "H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001"+ + "H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0004H\u09f8"+ + "\bH\u000bH\fH\u09f9\u0003H\u09fc\bH\u0001I\u0001I\u0003I\u0a00\bI\u0001"+ + "I\u0001I\u0003I\u0a04\bI\u0001I\u0001I\u0001I\u0003I\u0a09\bI\u0001I\u0003"+ + "I\u0a0c\bI\u0001I\u0001I\u0001I\u0001I\u0003I\u0a12\bI\u0001I\u0001I\u0003"+ + "I\u0a16\bI\u0001I\u0001I\u0003I\u0a1a\bI\u0001J\u0001J\u0001J\u0003J\u0a1f"+ + "\bJ\u0001J\u0003J\u0a22\bJ\u0001J\u0001J\u0001J\u0001J\u0001J\u0003J\u0a29"+ + "\bJ\u0001J\u0003J\u0a2c\bJ\u0001J\u0003J\u0a2f\bJ\u0001J\u0001J\u0001"+ + "J\u0001J\u0001J\u0001J\u0003J\u0a37\bJ\u0001J\u0001J\u0003J\u0a3b\bJ\u0003"+ + "J\u0a3d\bJ\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0003K\u0a45\bK\u0001"+ + "K\u0001K\u0001K\u0001K\u0001K\u0003K\u0a4c\bK\u0001K\u0003K\u0a4f\bK\u0001"+ + "K\u0001K\u0003K\u0a53\bK\u0001K\u0001K\u0001K\u0001K\u0003K\u0a59\bK\u0001"+ + "K\u0003K\u0a5c\bK\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001"+ + "L\u0001L\u0001L\u0001L\u0003L\u0a69\bL\u0001L\u0001L\u0001L\u0001L\u0003"+ + "L\u0a6f\bL\u0001L\u0001L\u0001L\u0001L\u0003L\u0a75\bL\u0001L\u0001L\u0001"+ + "L\u0001L\u0003L\u0a7b\bL\u0001L\u0001L\u0001L\u0001L\u0003L\u0a81\bL\u0001"+ + "L\u0001L\u0001L\u0001L\u0003L\u0a87\bL\u0001L\u0001L\u0003L\u0a8b\bL\u0001"+ + "L\u0001L\u0003L\u0a8f\bL\u0001L\u0001L\u0001M\u0001M\u0001M\u0001M\u0001"+ + "M\u0001M\u0001M\u0001M\u0001M\u0003M\u0a9c\bM\u0001M\u0001M\u0001M\u0001"+ + "M\u0001M\u0001M\u0003M\u0aa4\bM\u0001M\u0001M\u0003M\u0aa8\bM\u0001M\u0001"+ + "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0003M\u0ab1\bM\u0001N\u0001N\u0001"+ + "N\u0001N\u0001N\u0003N\u0ab8\bN\u0001N\u0001N\u0001N\u0001N\u0001N\u0001"+ + "N\u0001N\u0003N\u0ac1\bN\u0001N\u0001N\u0001N\u0001N\u0005N\u0ac7\bN\n"+ + "N\fN\u0aca\tN\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0001P"+ + "\u0001P\u0001P\u0001P\u0001P\u0001P\u0001P\u0003P\u0ada\bP\u0001P\u0001"+ + "P\u0003P\u0ade\bP\u0001P\u0001P\u0001P\u0001P\u0001P\u0003P\u0ae5\bP\u0001"+ + "P\u0001P\u0001P\u0001P\u0001P\u0001P\u0003P\u0aed\bP\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0003Q\u0af3\bQ\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0003Q\u0b07\bQ\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001"+ + "Q\u0001Q\u0001Q\u0004Q\u0b1c\bQ\u000bQ\fQ\u0b1d\u0003Q\u0b20\bQ\u0001"+ + "R\u0001R\u0001S\u0001S\u0001S\u0003S\u0b27\bS\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0003S\u0b32\bS\u0001S\u0001S\u0003"+ + "S\u0b36\bS\u0001S\u0001S\u0003S\u0b3a\bS\u0001T\u0001T\u0001T\u0001T\u0001"+ + "T\u0003T\u0b41\bT\u0001T\u0003T\u0b44\bT\u0001T\u0001T\u0001T\u0001T\u0001"+ + "T\u0003T\u0b4b\bT\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+ + "T\u0003T\u0b55\bT\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0001T\u0003"+ + "T\u0b5e\bT\u0001U\u0001U\u0003U\u0b62\bU\u0001U\u0001U\u0001U\u0001U\u0003"+ + "U\u0b68\bU\u0001U\u0001U\u0001U\u0003U\u0b6d\bU\u0001U\u0003U\u0b70\b"+ + "U\u0001U\u0001U\u0001U\u0001U\u0003U\u0b76\bU\u0001U\u0001U\u0001U\u0001"+ + "U\u0003U\u0b7c\bU\u0001U\u0001U\u0003U\u0b80\bU\u0001U\u0003U\u0b83\b"+ + "U\u0001U\u0001U\u0003U\u0b87\bU\u0001U\u0003U\u0b8a\bU\u0001U\u0003U\u0b8d"+ + "\bU\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0003U\u0b96\bU\u0003"+ + "U\u0b98\bU\u0001V\u0001V\u0001W\u0001W\u0001X\u0001X\u0001Y\u0001Y\u0001"+ + "Z\u0001Z\u0001[\u0001[\u0001\\\u0001\\\u0001]\u0001]\u0001^\u0001^\u0001"+ + "_\u0001_\u0001`\u0001`\u0001a\u0001a\u0001b\u0001b\u0001c\u0001c\u0001"+ + "d\u0001d\u0001e\u0001e\u0001e\u0003e\u0bbb\be\u0001e\u0003e\u0bbe\be\u0001"+ + "e\u0003e\u0bc1\be\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0003e\u0bc9"+ + "\be\u0001e\u0001e\u0001e\u0001e\u0001e\u0003e\u0bd0\be\u0001e\u0001e\u0001"+ + "e\u0003e\u0bd5\be\u0001e\u0001e\u0003e\u0bd9\be\u0001e\u0001e\u0003e\u0bdd"+ + "\be\u0001f\u0001f\u0001g\u0001g\u0001h\u0003h\u0be4\bh\u0001h\u0001h\u0001"+ + "h\u0003h\u0be9\bh\u0001h\u0001h\u0003h\u0bed\bh\u0001h\u0003h\u0bf0\b"+ + "h\u0001h\u0003h\u0bf3\bh\u0001h\u0001h\u0003h\u0bf7\bh\u0001h\u0001h\u0001"+ + "h\u0001h\u0001h\u0003h\u0bfe\bh\u0001h\u0003h\u0c01\bh\u0001i\u0001i\u0001"+ + "i\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\u0001j\u0003j\u0c2f\bj\u0001k\u0001k\u0001k\u0001k\u0001k\u0003k\u0c36"+ + "\bk\u0001k\u0001k\u0003k\u0c3a\bk\u0001l\u0001l\u0001l\u0001l\u0003l\u0c40"+ + "\bl\u0001l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001m\u0001m\u0001m\u0003"+ + "m\u0c4b\bm\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0003m\u0c53\bm\u0001"+ + "n\u0001n\u0001n\u0001n\u0003n\u0c59\bn\u0001n\u0001n\u0003n\u0c5d\bn\u0001"+ + "o\u0001o\u0001o\u0001o\u0003o\u0c63\bo\u0001o\u0001o\u0003o\u0c67\bo\u0001"+ + "p\u0001p\u0001p\u0001p\u0003p\u0c6d\bp\u0001p\u0001p\u0001q\u0001q\u0001"+ + "q\u0001q\u0003q\u0c75\bq\u0001q\u0001q\u0003q\u0c79\bq\u0001r\u0001r\u0001"+ + "r\u0001r\u0001r\u0003r\u0c80\br\u0001r\u0001r\u0003r\u0c84\br\u0001s\u0001"+ + "s\u0001s\u0001s\u0003s\u0c8a\bs\u0001s\u0001s\u0003s\u0c8e\bs\u0001t\u0001"+ + "t\u0001t\u0001t\u0001t\u0001t\u0003t\u0c96\bt\u0001t\u0001t\u0003t\u0c9a"+ + "\bt\u0001u\u0001u\u0001u\u0001u\u0001u\u0003u\u0ca1\bu\u0001u\u0001u\u0003"+ + "u\u0ca5\bu\u0001v\u0001v\u0001v\u0001v\u0003v\u0cab\bv\u0001v\u0001v\u0003"+ + "v\u0caf\bv\u0001w\u0001w\u0001w\u0001w\u0003w\u0cb5\bw\u0001w\u0001w\u0001"+ + "x\u0001x\u0001x\u0003x\u0cbc\bx\u0001x\u0001x\u0003x\u0cc0\bx\u0001x\u0001"+ + "x\u0003x\u0cc4\bx\u0001y\u0001y\u0003y\u0cc8\by\u0001y\u0001y\u0001y\u0003"+ + "y\u0ccd\by\u0001y\u0001y\u0003y\u0cd1\by\u0001z\u0001z\u0001z\u0001z\u0001"+ + "z\u0003z\u0cd8\bz\u0001z\u0001z\u0003z\u0cdc\bz\u0001{\u0001{\u0001|\u0001"+ + "|\u0001|\u0001|\u0001|\u0003|\u0ce5\b|\u0001|\u0001|\u0001|\u0001|\u0003"+ + "|\u0ceb\b|\u0001}\u0001}\u0001}\u0001}\u0001}\u0003}\u0cf2\b}\u0001}\u0001"+ + "}\u0001}\u0001}\u0003}\u0cf8\b}\u0001~\u0001~\u0001~\u0001~\u0001~\u0003"+ + "~\u0cff\b~\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f"+ + "\u0d05\b\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0003\u007f"+ + "\u0d0b\b\u007f\u0001\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0003\u0080"+ + "\u0d11\b\u0080\u0001\u0080\u0001\u0080\u0003\u0080\u0d15\b\u0080\u0001"+ + "\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0003\u0081\u0d1b\b\u0081\u0001"+ + "\u0081\u0001\u0081\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0003"+ + "\u0082\u0d23\b\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0003"+ + "\u0082\u0d29\b\u0082\u0001\u0083\u0001\u0083\u0001\u0083\u0001\u0083\u0003"+ + "\u0083\u0d2f\b\u0083\u0001\u0083\u0001\u0083\u0003\u0083\u0d33\b\u0083"+ + "\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0003\u0084\u0d39\b\u0084"+ + "\u0001\u0084\u0001\u0084\u0003\u0084\u0d3d\b\u0084\u0001\u0085\u0001\u0085"+ + "\u0001\u0085\u0001\u0085\u0003\u0085\u0d43\b\u0085\u0001\u0085\u0001\u0085"+ + "\u0003\u0085\u0d47\b\u0085\u0001\u0086\u0001\u0086\u0001\u0086\u0001\u0086"+ + "\u0003\u0086\u0d4d\b\u0086\u0001\u0086\u0001\u0086\u0001\u0087\u0001\u0087"+ + "\u0001\u0087\u0001\u0087\u0003\u0087\u0d55\b\u0087\u0001\u0087\u0001\u0087"+ + "\u0003\u0087\u0d59\b\u0087\u0001\u0088\u0001\u0088\u0001\u0088\u0001\u0088"+ + "\u0003\u0088\u0d5f\b\u0088\u0001\u0088\u0001\u0088\u0003\u0088\u0d63\b"+ + "\u0088\u0001\u0089\u0001\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u0d69"+ + "\b\u0089\u0001\u0089\u0001\u0089\u0001\u008a\u0001\u008a\u0001\u008a\u0001"+ + "\u008a\u0001\u008a\u0001\u008a\u0003\u008a\u0d73\b\u008a\u0001\u008a\u0001"+ + "\u008a\u0003\u008a\u0d77\b\u008a\u0001\u008b\u0001\u008b\u0001\u008b\u0001"+ + "\u008b\u0001\u008b\u0001\u008b\u0003\u008b\u0d7f\b\u008b\u0001\u008b\u0001"+ + "\u008b\u0003\u008b\u0d83\b\u008b\u0001\u008c\u0001\u008c\u0001\u008c\u0001"+ + "\u008c\u0001\u008c\u0001\u008c\u0003\u008c\u0d8b\b\u008c\u0001\u008c\u0001"+ + "\u008c\u0003\u008c\u0d8f\b\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0001"+ + "\u008d\u0001\u008d\u0001\u008d\u0003\u008d\u0d97\b\u008d\u0001\u008d\u0001"+ + "\u008d\u0003\u008d\u0d9b\b\u008d\u0001\u008e\u0001\u008e\u0001\u008e\u0001"+ + "\u008e\u0003\u008e\u0da1\b\u008e\u0001\u008e\u0001\u008e\u0001\u008e\u0001"+ + "\u008e\u0001\u008e\u0001\u008e\u0001\u008f\u0001\u008f\u0001\u008f\u0001"+ + "\u008f\u0003\u008f\u0dad\b\u008f\u0001\u008f\u0001\u008f\u0001\u008f\u0001"+ + "\u008f\u0003\u008f\u0db3\b\u008f\u0001\u0090\u0001\u0090\u0001\u0090\u0001"+ + "\u0090\u0003\u0090\u0db9\b\u0090\u0001\u0090\u0001\u0090\u0003\u0090\u0dbd"+ + "\b\u0090\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0091\u0003\u0091\u0dc3"+ + "\b\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001\u0092\u0001"+ + "\u0092\u0001\u0092\u0003\u0092\u0dcc\b\u0092\u0001\u0092\u0001\u0092\u0001"+ + "\u0092\u0001\u0092\u0001\u0092\u0001\u0092\u0003\u0092\u0dd4\b\u0092\u0001"+ + "\u0092\u0001\u0092\u0001\u0092\u0001\u0093\u0001\u0093\u0001\u0093\u0001"+ + "\u0093\u0003\u0093\u0ddd\b\u0093\u0001\u0093\u0001\u0093\u0003\u0093\u0de1"+ + "\b\u0093\u0001\u0094\u0001\u0094\u0001\u0094\u0003\u0094\u0de6\b\u0094"+ + "\u0001\u0095\u0001\u0095\u0003\u0095\u0dea\b\u0095\u0001\u0095\u0003\u0095"+ + "\u0ded\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095"+ + "\u0005\u0095\u0df4\b\u0095\n\u0095\f\u0095\u0df7\t\u0095\u0001\u0095\u0001"+ + "\u0095\u0003\u0095\u0dfb\b\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001"+ + "\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0001\u0095\u0003"+ + "\u0095\u0e06\b\u0095\u0001\u0096\u0001\u0096\u0001\u0097\u0001\u0097\u0001"+ + "\u0098\u0001\u0098\u0001\u0099\u0003\u0099\u0e0f\b\u0099\u0001\u0099\u0001"+ + "\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0e16\b\u0099\u0001"+ + "\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0e1c\b\u0099\u0001"+ + "\u0099\u0001\u0099\u0003\u0099\u0e20\b\u0099\u0001\u0099\u0003\u0099\u0e23"+ + "\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003\u0099\u0e29"+ + "\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001"+ + "\u0099\u0003\u0099\u0e31\b\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0003"+ + "\u0099\u0e36\b\u0099\u0001\u0099\u0003\u0099\u0e39\b\u0099\u0001\u0099"+ + "\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099\u0001\u0099"+ + "\u0003\u0099\u0e42\b\u0099\u0003\u0099\u0e44\b\u0099\u0003\u0099\u0e46"+ + "\b\u0099\u0001\u0099\u0003\u0099\u0e49\b\u0099\u0001\u009a\u0001\u009a"+ + "\u0001\u009a\u0001\u009b\u0001\u009b\u0001\u009c\u0001\u009c\u0003\u009c"+ + "\u0e52\b\u009c\u0001\u009c\u0003\u009c\u0e55\b\u009c\u0001\u009c\u0001"+ + "\u009c\u0003\u009c\u0e59\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\u0e6c\b\u009c\u0001\u009c\u0003\u009c\u0e6f"+ + "\b\u009c\u0001\u009c\u0003\u009c\u0e72\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\u0003\u009d"+ + "\u0e81\b\u009d\u0001\u009d\u0001\u009d\u0003\u009d\u0e85\b\u009d\u0003"+ + "\u009d\u0e87\b\u009d\u0001\u009d\u0003\u009d\u0e8a\b\u009d\u0003\u009d"+ + "\u0e8c\b\u009d\u0001\u009d\u0001\u009d\u0001\u009e\u0001\u009e\u0001\u009e"+ + "\u0001\u009e\u0003\u009e\u0e94\b\u009e\u0001\u009f\u0001\u009f\u0001\u009f"+ + "\u0001\u009f\u0001\u009f\u0001\u009f\u0003\u009f\u0e9c\b\u009f\u0001\u009f"+ + "\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0001\u009f\u0003\u009f"+ + "\u0ea4\b\u009f\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a0\u0001\u00a1"+ + "\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0003\u00a1"+ + "\u0eb0\b\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0003\u00a1"+ + "\u0eb6\b\u00a1\u0005\u00a1\u0eb8\b\u00a1\n\u00a1\f\u00a1\u0ebb\t\u00a1"+ + "\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0001\u00a1\u0003\u00a1\u0ec1\b\u00a1"+ + "\u0001\u00a2\u0001\u00a2\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3"+ + "\u0003\u00a3\u0ec9\b\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a3\u0001\u00a4"+ + "\u0001\u00a4\u0003\u00a4\u0ed0\b\u00a4\u0001\u00a4\u0001\u00a4\u0001\u00a5"+ + "\u0001\u00a5\u0001\u00a5\u0003\u00a5\u0ed7\b\u00a5\u0001\u00a6\u0001\u00a6"+ + "\u0001\u00a7\u0001\u00a7\u0003\u00a7\u0edd\b\u00a7\u0001\u00a8\u0001\u00a8"+ + "\u0001\u00a8\u0001\u00a8\u0001\u00a9\u0001\u00a9\u0003\u00a9\u0ee5\b\u00a9"+ + "\u0001\u00a9\u0001\u00a9\u0003\u00a9\u0ee9\b\u00a9\u0001\u00a9\u0001\u00a9"+ + "\u0001\u00aa\u0001\u00aa\u0001\u00aa\u0001\u00ab\u0001\u00ab\u0001\u00ab"+ + "\u0001\u00ab\u0003\u00ab\u0ef4\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\u0f19\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\u0f2d\b\u00ab"+ + "\u0001\u00ab\u0001\u00ab\u0001\u00ab\u0001\u00ac\u0003\u00ac\u0f33\b\u00ac"+ + "\u0001\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac\u0f38\b\u00ac\u0001\u00ac"+ + "\u0001\u00ac\u0003\u00ac\u0f3c\b\u00ac\u0001\u00ac\u0001\u00ac\u0003\u00ac"+ + "\u0f40\b\u00ac\u0001\u00ac\u0004\u00ac\u0f43\b\u00ac\u000b\u00ac\f\u00ac"+ + "\u0f44\u0001\u00ac\u0001\u00ac\u0004\u00ac\u0f49\b\u00ac\u000b\u00ac\f"+ + "\u00ac\u0f4a\u0001\u00ac\u0001\u00ac\u0003\u00ac\u0f4f\b\u00ac\u0001\u00ac"+ + "\u0003\u00ac\u0f52\b\u00ac\u0001\u00ac\u0003\u00ac\u0f55\b\u00ac\u0001"+ + "\u00ac\u0003\u00ac\u0f58\b\u00ac\u0001\u00ac\u0003\u00ac\u0f5b\b\u00ac"+ + "\u0001\u00ac\u0003\u00ac\u0f5e\b\u00ac\u0001\u00ac\u0003\u00ac\u0f61\b"+ + "\u00ac\u0001\u00ac\u0003\u00ac\u0f64\b\u00ac\u0001\u00ac\u0003\u00ac\u0f67"+ + "\b\u00ac\u0001\u00ac\u0003\u00ac\u0f6a\b\u00ac\u0001\u00ac\u0003\u00ac"+ + "\u0f6d\b\u00ac\u0001\u00ad\u0003\u00ad\u0f70\b\u00ad\u0001\u00ad\u0001"+ + "\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad\u0f76\b\u00ad\u0001\u00ad\u0003"+ + "\u00ad\u0f79\b\u00ad\u0001\u00ad\u0001\u00ad\u0003\u00ad\u0f7d\b\u00ad"+ + "\u0001\u00ad\u0001\u00ad\u0003\u00ad\u0f81\b\u00ad\u0001\u00ad\u0001\u00ad"+ + "\u0003\u00ad\u0f85\b\u00ad\u0001\u00ad\u0004\u00ad\u0f88\b\u00ad\u000b"+ + "\u00ad\f\u00ad\u0f89\u0001\u00ad\u0001\u00ad\u0004\u00ad\u0f8e\b\u00ad"+ + "\u000b\u00ad\f\u00ad\u0f8f\u0001\u00ad\u0001\u00ad\u0003\u00ad\u0f94\b"+ + "\u00ad\u0001\u00ad\u0003\u00ad\u0f97\b\u00ad\u0001\u00ad\u0003\u00ad\u0f9a"+ + "\b\u00ad\u0001\u00ad\u0003\u00ad\u0f9d\b\u00ad\u0001\u00ad\u0003\u00ad"+ + "\u0fa0\b\u00ad\u0001\u00ad\u0003\u00ad\u0fa3\b\u00ad\u0001\u00ad\u0003"+ + "\u00ad\u0fa6\b\u00ad\u0001\u00ad\u0003\u00ad\u0fa9\b\u00ad\u0001\u00ad"+ + "\u0003\u00ad\u0fac\b\u00ad\u0001\u00ad\u0003\u00ad\u0faf\b\u00ad\u0001"+ + "\u00ad\u0003\u00ad\u0fb2\b\u00ad\u0001\u00ae\u0001\u00ae\u0003\u00ae\u0fb6"+ + "\b\u00ae\u0001\u00ae\u0001\u00ae\u0001\u00ae\u0005\u00ae\u0fbb\b\u00ae"+ + "\n\u00ae\f\u00ae\u0fbe\t\u00ae\u0001\u00af\u0001\u00af\u0001\u00af\u0001"+ + "\u00af\u0001\u00af\u0003\u00af\u0fc5\b\u00af\u0001\u00af\u0001\u00af\u0001"+ + "\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0001\u00af\u0003\u00af\u0fce"+ + "\b\u00af\u0001\u00af\u0001\u00af\u0001\u00b0\u0001\u00b0\u0003\u00b0\u0fd4"+ + "\b\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0\u0fda"+ + "\b\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0\u0fde\b\u00b0\u0001\u00b0"+ + "\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0001\u00b0\u0003\u00b0\u0fe5\b\u00b0"+ + "\u0003\u00b0\u0fe7\b\u00b0\u0001\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b1"+ + "\u0003\u00b1\u0fed\b\u00b1\u0001\u00b1\u0001\u00b1\u0001\u00b2\u0001\u00b2"+ + "\u0003\u00b2\u0ff3\b\u00b2\u0001\u00b2\u0001\u00b2\u0001\u00b2\u0003\u00b2"+ + "\u0ff8\b\u00b2\u0001\u00b2\u0001\u00b2\u0003\u00b2\u0ffc\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\u1009"+ + "\b\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0001\u00b4\u0003"+ + "\u00b4\u1010\b\u00b4\u0001\u00b4\u0003\u00b4\u1013\b\u00b4\u0001\u00b5"+ + "\u0001\u00b5\u0001\u00b5\u0005\u00b5\u1018\b\u00b5\n\u00b5\f\u00b5\u101b"+ + "\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\u102a\b\u00b6\u0001\u00b7\u0001\u00b7\u0001"+ + "\u00b7\u0001\u00b7\u0001\u00b7\u0003\u00b7\u1031\b\u00b7\u0001\u00b8\u0001"+ + "\u00b8\u0003\u00b8\u1035\b\u00b8\u0001\u00b8\u0003\u00b8\u1038\b\u00b8"+ + "\u0001\u00b8\u0001\u00b8\u0003\u00b8\u103c\b\u00b8\u0001\u00b8\u0001\u00b8"+ + "\u0003\u00b8\u1040\b\u00b8\u0001\u00b8\u0003\u00b8\u1043\b\u00b8\u0001"+ + "\u00b8\u0001\u00b8\u0003\u00b8\u1047\b\u00b8\u0001\u00b8\u0003\u00b8\u104a"+ + "\b\u00b8\u0001\u00b9\u0001\u00b9\u0001\u00b9\u0003\u00b9\u104f\b\u00b9"+ + "\u0001\u00ba\u0003\u00ba\u1052\b\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba"+ + "\u1056\b\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u105a\b\u00ba\u0001"+ + "\u00ba\u0003\u00ba\u105d\b\u00ba\u0001\u00ba\u0003\u00ba\u1060\b\u00ba"+ + "\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u1065\b\u00ba\u0001\u00ba"+ + "\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0001\u00ba\u0003\u00ba\u106c\b\u00ba"+ + "\u0001\u00ba\u0003\u00ba\u106f\b\u00ba\u0001\u00bb\u0001\u00bb\u0001\u00bc"+ + "\u0001\u00bc\u0001\u00bc\u0005\u00bc\u1076\b\u00bc\n\u00bc\f\u00bc\u1079"+ + "\t\u00bc\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0003"+ + "\u00bd\u1080\b\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0001"+ + "\u00bd\u0003\u00bd\u1087\b\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u108b"+ + "\b\u00bd\u0001\u00bd\u0003\u00bd\u108e\b\u00bd\u0001\u00bd\u0003\u00bd"+ + "\u1091\b\u00bd\u0001\u00bd\u0003\u00bd\u1094\b\u00bd\u0001\u00bd\u0001"+ + "\u00bd\u0003\u00bd\u1098\b\u00bd\u0001\u00bd\u0003\u00bd\u109b\b\u00bd"+ + "\u0001\u00bd\u0003\u00bd\u109e\b\u00bd\u0001\u00bd\u0001\u00bd\u0001\u00bd"+ + "\u0001\u00bd\u0001\u00bd\u0001\u00bd\u0003\u00bd\u10a6\b\u00bd\u0003\u00bd"+ + "\u10a8\b\u00bd\u0003\u00bd\u10aa\b\u00bd\u0001\u00be\u0003\u00be\u10ad"+ + "\b\u00be\u0001\u00be\u0001\u00be\u0001\u00be\u0004\u00be\u10b2\b\u00be"+ + "\u000b\u00be\f\u00be\u10b3\u0001\u00be\u0001\u00be\u0004\u00be\u10b8\b"+ + "\u00be\u000b\u00be\f\u00be\u10b9\u0001\u00be\u0001\u00be\u0003\u00be\u10be"+ + "\b\u00be\u0001\u00be\u0003\u00be\u10c1\b\u00be\u0001\u00be\u0003\u00be"+ + "\u10c4\b\u00be\u0001\u00be\u0003\u00be\u10c7\b\u00be\u0001\u00be\u0003"+ + "\u00be\u10ca\b\u00be\u0001\u00be\u0003\u00be\u10cd\b\u00be\u0001\u00bf"+ + "\u0001\u00bf\u0001\u00bf\u0001\u00bf\u0003\u00bf\u10d3\b\u00bf\u0003\u00bf"+ + "\u10d5\b\u00bf\u0001\u00bf\u0001\u00bf\u0001\u00c0\u0001\u00c0\u0001\u00c0"+ + "\u0001\u00c0\u0005\u00c0\u10dd\b\u00c0\n\u00c0\f\u00c0\u10e0\t\u00c0\u0001"+ + "\u00c1\u0001\u00c1\u0001\u00c1\u0001\u00c2\u0001\u00c2\u0001\u00c2\u0001"+ + "\u00c2\u0001\u00c2\u0005\u00c2\u10ea\b\u00c2\n\u00c2\f\u00c2\u10ed\t\u00c2"+ + "\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3"+ + "\u0001\u00c3\u0001\u00c3\u0003\u00c3\u10f7\b\u00c3\u0001\u00c3\u0001\u00c3"+ + "\u0001\u00c3\u0003\u00c3\u10fc\b\u00c3\u0005\u00c3\u10fe\b\u00c3\n\u00c3"+ + "\f\u00c3\u1101\t\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3\u0001\u00c3"+ + "\u0001\u00c3\u0003\u00c3\u1108\b\u00c3\u0001\u00c4\u0001\u00c4\u0001\u00c4"+ + "\u0001\u00c4\u0005\u00c4\u110e\b\u00c4\n\u00c4\f\u00c4\u1111\t\u00c4\u0001"+ + "\u00c4\u0001\u00c4\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0001\u00c5\u0005"+ + "\u00c5\u1119\b\u00c5\n\u00c5\f\u00c5\u111c\t\u00c5\u0001\u00c6\u0001\u00c6"+ + "\u0003\u00c6\u1120\b\u00c6\u0001\u00c6\u0003\u00c6\u1123\b\u00c6\u0001"+ + "\u00c6\u0003\u00c6\u1126\b\u00c6\u0001\u00c6\u0001\u00c6\u0001\u00c6\u0003"+ + "\u00c6\u112b\b\u00c6\u0001\u00c6\u0003\u00c6\u112e\b\u00c6\u0001\u00c6"+ + "\u0003\u00c6\u1131\b\u00c6\u0005\u00c6\u1133\b\u00c6\n\u00c6\f\u00c6\u1136"+ + "\t\u00c6\u0001\u00c7\u0001\u00c7\u0003\u00c7\u113a\b\u00c7\u0001\u00c7"+ + "\u0001\u00c7\u0003\u00c7\u113e\b\u00c7\u0001\u00c8\u0001\u00c8\u0001\u00c8"+ + "\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8\u0001\u00c8"+ + "\u0001\u00c8\u0003\u00c8\u114a\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\u1158\b\u00cb\u0001\u00cc"+ + "\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0001\u00cc\u0005\u00cc"+ + "\u1160\b\u00cc\n\u00cc\f\u00cc\u1163\t\u00cc\u0001\u00cc\u0003\u00cc\u1166"+ + "\b\u00cc\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001\u00cd\u0001"+ + "\u00cd\u0001\u00cd\u0001\u00ce\u0001\u00ce\u0003\u00ce\u1171\b\u00ce\u0001"+ + "\u00ce\u0005\u00ce\u1174\b\u00ce\n\u00ce\f\u00ce\u1177\t\u00ce\u0001\u00ce"+ + "\u0001\u00ce\u0003\u00ce\u117b\b\u00ce\u0001\u00ce\u0005\u00ce\u117e\b"+ + "\u00ce\n\u00ce\f\u00ce\u1181\t\u00ce\u0001\u00ce\u0003\u00ce\u1184\b\u00ce"+ + "\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0001\u00cf\u0005\u00cf"+ + "\u118b\b\u00cf\n\u00cf\f\u00cf\u118e\t\u00cf\u0001\u00d0\u0001\u00d0\u0003"+ + "\u00d0\u1192\b\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0003"+ + "\u00d0\u1198\b\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001\u00d0\u0001"+ + "\u00d0\u0001\u00d0\u0005\u00d0\u11a0\b\u00d0\n\u00d0\f\u00d0\u11a3\t\u00d0"+ + "\u0003\u00d0\u11a5\b\u00d0\u0001\u00d1\u0001\u00d1\u0001\u00d1\u0001\u00d1"+ + "\u0003\u00d1\u11ab\b\u00d1\u0001\u00d2\u0001\u00d2\u0001\u00d2\u0003\u00d2"+ + "\u11b0\b\u00d2\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0003\u00d3\u11b5\b"+ + "\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d3\u0001\u00d4\u0001\u00d4\u0001"+ + "\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0003"+ + "\u00d4\u11c2\b\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0005"+ + "\u00d4\u11c8\b\u00d4\n\u00d4\f\u00d4\u11cb\t\u00d4\u0003\u00d4\u11cd\b"+ + "\u00d4\u0001\u00d4\u0001\u00d4\u0001\u00d4\u0005\u00d4\u11d2\b\u00d4\n"+ + "\u00d4\f\u00d4\u11d5\t\u00d4\u0001\u00d5\u0001\u00d5\u0001\u00d5\u0005"+ + "\u00d5\u11da\b\u00d5\n\u00d5\f\u00d5\u11dd\t\u00d5\u0001\u00d6\u0001\u00d6"+ + "\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0001\u00d6\u0003\u00d6"+ + "\u11e6\b\u00d6\u0003\u00d6\u11e8\b\u00d6\u0001\u00d7\u0001\u00d7\u0001"+ + "\u00d7\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0004\u00d8\u11fd"+ + "\b\u00d8\u000b\u00d8\f\u00d8\u11fe\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0004\u00d8\u1205\b\u00d8\u000b\u00d8\f\u00d8\u1206\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u1238"+ + "\b\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u124a"+ + "\b\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8\u124f\b\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0003\u00d8\u125f\b\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0001\u00d8\u0003\u00d8\u1271\b\u00d8\u0001\u00d8\u0001\u00d8"+ + "\u0001\u00d8\u0003\u00d8\u1276\b\u00d8\u0001\u00d8\u0001\u00d8\u0003\u00d8"+ + "\u127a\b\u00d8\u0001\u00d8\u0004\u00d8\u127d\b\u00d8\u000b\u00d8\f\u00d8"+ + "\u127e\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0004\u00d8\u1284\b\u00d8\u000b"+ + "\u00d8\f\u00d8\u1285\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0003\u00d8\u1293\b\u00d8\u0001\u00d8\u0001\u00d8\u0001\u00d8\u0001"+ + "\u00d8\u0001\u00d8\u0001\u00d8\u0005\u00d8\u129b\b\u00d8\n\u00d8\f\u00d8"+ + "\u129e\t\u00d8\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0001\u00d9"+ + "\u0001\u00d9\u0001\u00d9\u0001\u00d9\u0003\u00d9\u12a8\b\u00d9\u0003\u00d9"+ + "\u12aa\b\u00d9\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da"+ + "\u0003\u00da\u12b1\b\u00da\u0001\u00da\u0001\u00da\u0001\u00da\u0001\u00da"+ + "\u0001\u00da\u0001\u00da\u0005\u00da\u12b9\b\u00da\n\u00da\f\u00da\u12bc"+ + "\t\u00da\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001"+ + "\u00db\u0001\u00db\u0004\u00db\u12c5\b\u00db\u000b\u00db\f\u00db\u12c6"+ + "\u0001\u00db\u0001\u00db\u0003\u00db\u12cb\b\u00db\u0001\u00db\u0001\u00db"+ + "\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db\u0001\u00db"+ + "\u0004\u00db\u12d5\b\u00db\u000b\u00db\f\u00db\u12d6\u0001\u00db\u0001"+ + "\u00db\u0003\u00db\u12db\b\u00db\u0001\u00db\u0001\u00db\u0003\u00db\u12df"+ + "\b\u00db\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dc\u0005\u00dc\u12e5"+ + "\b\u00dc\n\u00dc\f\u00dc\u12e8\t\u00dc\u0001\u00dc\u0001\u00dc\u0001\u00dd"+ + "\u0003\u00dd\u12ed\b\u00dd\u0001\u00dd\u0001\u00dd\u0001\u00dd\u0005\u00dd"+ + "\u12f2\b\u00dd\n\u00dd\f\u00dd\u12f5\t\u00dd\u0001\u00dd\u0003\u00dd\u12f8"+ + "\b\u00dd\u0001\u00de\u0003\u00de\u12fb\b\u00de\u0001\u00de\u0003\u00de"+ + "\u12fe\b\u00de\u0001\u00de\u0003\u00de\u1301\b\u00de\u0001\u00df\u0001"+ + "\u00df\u0001\u00df\u0005\u00df\u1306\b\u00df\n\u00df\f\u00df\u1309\t\u00df"+ + "\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0001\u00e0\u0003\u00e0"+ + "\u1310\b\u00e0\u0001\u00e1\u0001\u00e1\u0001\u00e1\u0005\u00e1\u1315\b"+ + "\u00e1\n\u00e1\f\u00e1\u1318\t\u00e1\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2"+ + "\u1322\b\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2"+ + "\u1328\b\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1332\b\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1338\b\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u133e\b\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1349\b\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1357\b\u00e2"+ + "\u0001\u00e2\u0003\u00e2\u135a\b\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1369\b\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u137b\b\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1380\b\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1386\b\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0003\u00e2\u138b\b\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1391\b\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0003\u00e2\u1397\b\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0003\u00e2\u13a1\b\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2\u0001\u00e2"+ + "\u0003\u00e2\u13a7\b\u00e2\u0001\u00e2\u0003\u00e2\u13aa\b\u00e2\u0001"+ + "\u00e3\u0001\u00e3\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0001\u00e4\u0003"+ + "\u00e4\u13b2\b\u00e4\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0003\u00e5\u13b7"+ + "\b\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0005\u00e5\u13bc\b\u00e5"+ + "\n\u00e5\f\u00e5\u13bf\t\u00e5\u0001\u00e5\u0003\u00e5\u13c2\b\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0003\u00e5\u13cb\b\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0003\u00e5\u13d7\b\u00e5\u0001\u00e5\u0001\u00e5\u0001\u00e5\u0001"+ + "\u00e5\u0001\u00e5\u0005\u00e5\u13de\b\u00e5\n\u00e5\f\u00e5\u13e1\t\u00e5"+ + "\u0003\u00e5\u13e3\b\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\u13f1\b\u00e5\u0003\u00e5\u13f3\b"+ + "\u00e5\u0001\u00e6\u0001\u00e6\u0003\u00e6\u13f7\b\u00e6\u0001\u00e7\u0001"+ + "\u00e7\u0001\u00e7\u0005\u00e7\u13fc\b\u00e7\n\u00e7\f\u00e7\u13ff\t\u00e7"+ + "\u0001\u00e8\u0001\u00e8\u0001\u00e8\u0005\u00e8\u1404\b\u00e8\n\u00e8"+ + "\f\u00e8\u1407\t\u00e8\u0001\u00e9\u0001\u00e9\u0001\u00e9\u0003\u00e9"+ + "\u140c\b\u00e9\u0001\u00ea\u0001\u00ea\u0001\u00ea\u0005\u00ea\u1411\b"+ + "\u00ea\n\u00ea\f\u00ea\u1414\t\u00ea\u0001\u00eb\u0001\u00eb\u0001\u00ec"+ + "\u0001\u00ec\u0003\u00ec\u141a\b\u00ec\u0001\u00ec\u0001\u00ec\u0003\u00ec"+ + "\u141e\b\u00ec\u0001\u00ec\u0005\u00ec\u1421\b\u00ec\n\u00ec\f\u00ec\u1424"+ + "\t\u00ec\u0001\u00ed\u0001\u00ed\u0001\u00ed\u0005\u00ed\u1429\b\u00ed"+ + "\n\u00ed\f\u00ed\u142c\t\u00ed\u0001\u00ee\u0001\u00ee\u0003\u00ee\u1430"+ + "\b\u00ee\u0001\u00ef\u0001\u00ef\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001"+ + "\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001"+ + "\u00f0\u0001\u00f0\u0005\u00f0\u143f\b\u00f0\n\u00f0\f\u00f0\u1442\t\u00f0"+ + "\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0003\u00f0\u1447\b\u00f0\u0003\u00f0"+ + "\u1449\b\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0"+ + "\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0001\u00f0\u0003\u00f0\u1454\b\u00f0"+ + "\u0001\u00f0\u0001\u00f0\u0003\u00f0\u1458\b\u00f0\u0001\u00f1\u0001\u00f1"+ + "\u0001\u00f1\u0001\u00f1\u0001\u00f1\u0005\u00f1\u145f\b\u00f1\n\u00f1"+ + "\f\u00f1\u1462\t\u00f1\u0003\u00f1\u1464\b\u00f1\u0001\u00f1\u0001\u00f1"+ + "\u0001\u00f2\u0001\u00f2\u0003\u00f2\u146a\b\u00f2\u0001\u00f2\u0001\u00f2"+ + "\u0003\u00f2\u146e\b\u00f2\u0001\u00f2\u0003\u00f2\u1471\b\u00f2\u0001"+ + "\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0005"+ + "\u00f2\u1479\b\u00f2\n\u00f2\f\u00f2\u147c\t\u00f2\u0001\u00f2\u0001\u00f2"+ + "\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0003\u00f2\u1484\b\u00f2"+ + "\u0003\u00f2\u1486\b\u00f2\u0001\u00f2\u0003\u00f2\u1489\b\u00f2\u0001"+ + "\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0003\u00f2\u148f\b\u00f2\u0001"+ + "\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0005\u00f2\u1496"+ + "\b\u00f2\n\u00f2\f\u00f2\u1499\t\u00f2\u0001\u00f2\u0001\u00f2\u0003\u00f2"+ + "\u149d\b\u00f2\u0001\u00f2\u0003\u00f2\u14a0\b\u00f2\u0001\u00f2\u0001"+ + "\u00f2\u0001\u00f2\u0003\u00f2\u14a5\b\u00f2\u0001\u00f2\u0003\u00f2\u14a8"+ + "\b\u00f2\u0001\u00f2\u0003\u00f2\u14ab\b\u00f2\u0001\u00f2\u0001\u00f2"+ + "\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0005\u00f2\u14b3\b\u00f2"+ + "\n\u00f2\f\u00f2\u14b6\t\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0003"+ + "\u00f2\u14bb\b\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001"+ + "\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0001\u00f2\u0005"+ + "\u00f2\u14c7\b\u00f2\n\u00f2\f\u00f2\u14ca\t\u00f2\u0001\u00f2\u0001\u00f2"+ + "\u0003\u00f2\u14ce\b\u00f2\u0001\u00f2\u0001\u00f2\u0003\u00f2\u14d2\b"+ + "\u00f2\u0001\u00f2\u0001\u00f2\u0003\u00f2\u14d6\b\u00f2\u0001\u00f2\u0001"+ + "\u00f2\u0003\u00f2\u14da\b\u00f2\u0001\u00f2\u0001\u00f2\u0003\u00f2\u14de"+ + "\b\u00f2\u0001\u00f2\u0003\u00f2\u14e1\b\u00f2\u0005\u00f2\u14e3\b\u00f2"+ + "\n\u00f2\f\u00f2\u14e6\t\u00f2\u0001\u00f3\u0003\u00f3\u14e9\b\u00f3\u0001"+ + "\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0005\u00f3\u14ef\b\u00f3\n"+ + "\u00f3\f\u00f3\u14f2\t\u00f3\u0003\u00f3\u14f4\b\u00f3\u0001\u00f3\u0003"+ + "\u00f3\u14f7\b\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001\u00f3\u0001"+ + "\u00f3\u0003\u00f3\u14fe\b\u00f3\u0001\u00f4\u0003\u00f4\u1501\b\u00f4"+ + "\u0001\u00f4\u0001\u00f4\u0001\u00f4\u0003\u00f4\u1506\b\u00f4\u0001\u00f4"+ + "\u0001\u00f4\u0001\u00f4\u0003\u00f4\u150b\b\u00f4\u0001\u00f4\u0001\u00f4"+ + "\u0001\u00f4\u0003\u00f4\u1510\b\u00f4\u0001\u00f4\u0001\u00f4\u0001\u00f4"+ + "\u0003\u00f4\u1515\b\u00f4\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0001\u00f5"+ + "\u0001\u00f5\u0001\u00f5\u0001\u00f5\u0005\u00f5\u151e\b\u00f5\n\u00f5"+ + "\f\u00f5\u1521\t\u00f5\u0001\u00f5\u0001\u00f5\u0003\u00f5\u1525\b\u00f5"+ + "\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6"+ + "\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6"+ + "\u0003\u00f6\u1533\b\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6\u0001\u00f6"+ + "\u0001\u00f6\u0001\u00f6\u0005\u00f6\u153b\b\u00f6\n\u00f6\f\u00f6\u153e"+ + "\t\u00f6\u0001\u00f7\u0001\u00f7\u0003\u00f7\u1542\b\u00f7\u0001\u00f7"+ + "\u0003\u00f7\u1545\b\u00f7\u0001\u00f7\u0001\u00f7\u0003\u00f7\u1549\b"+ + "\u00f7\u0001\u00f7\u0003\u00f7\u154c\b\u00f7\u0001\u00f7\u0001\u00f7\u0001"+ + "\u00f7\u0001\u00f7\u0001\u00f7\u0003\u00f7\u1553\b\u00f7\u0001\u00f7\u0003"+ + "\u00f7\u1556\b\u00f7\u0001\u00f7\u0001\u00f7\u0003\u00f7\u155a\b\u00f7"+ + "\u0001\u00f8\u0001\u00f8\u0001\u00f8\u0001\u00f9\u0004\u00f9\u1560\b\u00f9"+ + "\u000b\u00f9\f\u00f9\u1561\u0001\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa"+ + "\u0001\u00fa\u0003\u00fa\u1569\b\u00fa\u0001\u00fa\u0001\u00fa\u0001\u00fa"+ + "\u0001\u00fa\u0003\u00fa\u156f\b\u00fa\u0001\u00fb\u0001\u00fb\u0001\u00fb"+ + "\u0001\u00fb\u0001\u00fb\u0003\u00fb\u1576\b\u00fb\u0001\u00fb\u0003\u00fb"+ + "\u1579\b\u00fb\u0001\u00fb\u0003\u00fb\u157c\b\u00fb\u0001\u00fb\u0001"+ + "\u00fb\u0003\u00fb\u1580\b\u00fb\u0001\u00fc\u0001\u00fc\u0003\u00fc\u1584"+ + "\b\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001"+ + "\u00fc\u0003\u00fc\u158c\b\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\u159d\b\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\u15aa\b\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001"+ + "\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0003\u00fc\u15b4"+ + "\b\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0003"+ + "\u00fc\u15bb\b\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0003\u00fc\u15c0"+ + "\b\u00fc\u0001\u00fc\u0001\u00fc\u0001\u00fc\u0003\u00fc\u15c5\b\u00fc"+ + "\u0003\u00fc\u15c7\b\u00fc\u0001\u00fc\u0003\u00fc\u15ca\b\u00fc\u0001"+ + "\u00fc\u0003\u00fc\u15cd\b\u00fc\u0001\u00fc\u0001\u00fc\u0003\u00fc\u15d1"+ + "\b\u00fc\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0001\u00fd\u0003\u00fd\u15d7"+ + "\b\u00fd\u0001\u00fe\u0001\u00fe\u0001\u00fe\u0005\u00fe\u15dc\b\u00fe"+ + "\n\u00fe\f\u00fe\u15df\t\u00fe\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001"+ + "\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001\u00ff\u0001"+ + "\u00ff\u0001\u00ff\u0003\u00ff\u15ec\b\u00ff\u0001\u0100\u0001\u0100\u0001"+ + "\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0003"+ + "\u0101\u15f6\b\u0101\u0001\u0101\u0001\u0101\u0001\u0101\u0005\u0101\u15fb"+ + "\b\u0101\n\u0101\f\u0101\u15fe\t\u0101\u0001\u0102\u0001\u0102\u0001\u0103"+ + "\u0001\u0103\u0001\u0104\u0001\u0104\u0001\u0105\u0001\u0105\u0001\u0106"+ + "\u0001\u0106\u0001\u0107\u0001\u0107\u0001\u0108\u0001\u0108\u0001\u0109"+ + "\u0001\u0109\u0001\u0109\u0000\u0005\u01b0\u01b4\u01e4\u01ec\u0202\u010a"+ + "\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\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\u0318"+ + "\u0318\u0002\u0000\u0109\u0109\u027d\u027d\u0001\u0000\u02af\u02b1\u0002"+ + "\u0000\u00c5\u00c5\u0261\u0261\u0002\u0000\u0172\u0172\u0309\u0309\u0005"+ + "\u0000\u0010\u0010\u00a3\u00a3\u0116\u0116\u01fe\u01fe\u026a\u026a\u0004"+ + "\u0000\u00a3\u00a3\u0116\u0116\u01fe\u01fe\u026a\u026a\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\u026d\u026d\u0002\u0000\u0010\u0010\u0306"+ + "\u0306\u0002\u0000\u00ec\u00ec\u0109\u0109\u0005\u0000\u0092\u0092\u010c"+ + "\u010c\u01f3\u01f3\u0235\u0235\u0237\u0237\u0002\u0000\u024b\u024b\u028a"+ + "\u028a\u0003\u0000\u023b\u023b\u023d\u023d\u0266\u0266\u0002\u0000\u013a"+ + "\u013a\u0205\u0205\u0002\u0000\u009f\u009f\u0105\u0105\u0002\u0000tt\u01d9"+ + "\u01d9\u0005\u0000\u0016\u0016\u00b4\u00b4\u00eb\u00eb\u00ed\u00ed\u027f"+ + "\u027f\u0002\u0000\u0083\u0083\u01e7\u01e7\u0005\u0000\u0016\u001655z"+ + "z\u0246\u0246\u027f\u027f\u0004\u0000\u028c\u028c\u02df\u02df\u02f0\u02f0"+ + "\u02f8\u02f8\u0002\u0000\u01bc\u01bc\u01ef\u01ef\u0003\u0000\u00cb\u00cb"+ + "\u011c\u011c\u0262\u0262\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\u02fc\u02fc\u0004\u0000\u0313\u0313"+ + "\u0315\u0315\u032e\u032e\u0334\u0334\u0002\u0000\u0338\u0338\u033b\u033b"+ + "\u0002\u0000\u0010\u0010\u016d\u016d\u0002\u0000\u0317\u0317\u0332\u0333"+ + "\u0003\u0000\u02fe\u02fe\u032f\u032f\u033a\u033a\u0002\u0000\u032e\u032e"+ + "\u0334\u0334\f\u0000\u0017\u0017\u016d\u016d\u0187\u0187\u030e\u0312\u0319"+ + "\u0319\u031c\u0324\u0327\u0328\u032a\u032d\u0330\u0331\u0335\u0337\u0339"+ + "\u0339\u033b\u0342\u0005\u0000\u0316\u0316\u0318\u0318\u031a\u031b\u0325"+ + "\u0326\u0329\u0329\u0004\u0000\u0109\u0109\u0113\u0113\u018c\u018c\u027d"+ + "\u027d\u0002\u0000\u0287\u0287\u0289\u0289\u0002\u0000\u0305\u0306\u0309"+ + "\u030a\u0001\u0000\u02be\u02c3\u0002\u0000\u001c\u001c\u00ab\u00abn\u0000"+ + "\u0001\u0001\u0004\u000e\u0011\u0014\u0018\u0019\u001d\u001f!$&,./124"+ + "46=@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"+ + "\u0249\u024b\u0261\u0264\u0265\u0267\u026c\u026e\u0271\u0273\u0274\u0276"+ + "\u027b\u027e\u027e\u0280\u0281\u0283\u0283\u0285\u0285\u0288\u028b\u028d"+ + "\u028d\u028f\u028f\u02f0\u02f0\u19c9\u0000\u0214\u0001\u0000\u0000\u0000"+ + "\u0002\u0255\u0001\u0000\u0000\u0000\u0004\u0257\u0001\u0000\u0000\u0000"+ + "\u0006\u0281\u0001\u0000\u0000\u0000\b\u02a1\u0001\u0000\u0000\u0000\n"+ + "\u02be\u0001\u0000\u0000\u0000\f\u02d5\u0001\u0000\u0000\u0000\u000e\u02d7"+ + "\u0001\u0000\u0000\u0000\u0010\u02d9\u0001\u0000\u0000\u0000\u0012\u0327"+ + "\u0001\u0000\u0000\u0000\u0014\u034a\u0001\u0000\u0000\u0000\u0016\u035b"+ + "\u0001\u0000\u0000\u0000\u0018\u035d\u0001\u0000\u0000\u0000\u001a\u040b"+ + "\u0001\u0000\u0000\u0000\u001c\u040d\u0001\u0000\u0000\u0000\u001e\u0453"+ + "\u0001\u0000\u0000\u0000 \u0455\u0001\u0000\u0000\u0000\"\u046c\u0001"+ + "\u0000\u0000\u0000$\u04b4\u0001\u0000\u0000\u0000&\u04cd\u0001\u0000\u0000"+ + "\u0000(\u04cf\u0001\u0000\u0000\u0000*\u04da\u0001\u0000\u0000\u0000,"+ + "\u04dc\u0001\u0000\u0000\u0000.\u04ff\u0001\u0000\u0000\u00000\u0501\u0001"+ + "\u0000\u0000\u00002\u051e\u0001\u0000\u0000\u00004\u0554\u0001\u0000\u0000"+ + "\u00006\u056f\u0001\u0000\u0000\u00008\u05bf\u0001\u0000\u0000\u0000:"+ + "\u05c1\u0001\u0000\u0000\u0000<\u05db\u0001\u0000\u0000\u0000>\u05dd\u0001"+ + "\u0000\u0000\u0000@\u05e6\u0001\u0000\u0000\u0000B\u0617\u0001\u0000\u0000"+ + "\u0000D\u0631\u0001\u0000\u0000\u0000F\u0672\u0001\u0000\u0000\u0000H"+ + "\u0682\u0001\u0000\u0000\u0000J\u0684\u0001\u0000\u0000\u0000L\u06a7\u0001"+ + "\u0000\u0000\u0000N\u0704\u0001\u0000\u0000\u0000P\u0706\u0001\u0000\u0000"+ + "\u0000R\u0708\u0001\u0000\u0000\u0000T\u071c\u0001\u0000\u0000\u0000V"+ + "\u0731\u0001\u0000\u0000\u0000X\u0733\u0001\u0000\u0000\u0000Z\u0735\u0001"+ + "\u0000\u0000\u0000\\\u0737\u0001\u0000\u0000\u0000^\u0743\u0001\u0000"+ + "\u0000\u0000`\u0745\u0001\u0000\u0000\u0000b\u0750\u0001\u0000\u0000\u0000"+ + "d\u0752\u0001\u0000\u0000\u0000f\u0754\u0001\u0000\u0000\u0000h\u0756"+ + "\u0001\u0000\u0000\u0000j\u0758\u0001\u0000\u0000\u0000l\u075a\u0001\u0000"+ + "\u0000\u0000n\u0783\u0001\u0000\u0000\u0000p\u0785\u0001\u0000\u0000\u0000"+ + "r\u08a8\u0001\u0000\u0000\u0000t\u08aa\u0001\u0000\u0000\u0000v\u08d8"+ + "\u0001\u0000\u0000\u0000x\u08da\u0001\u0000\u0000\u0000z\u08f9\u0001\u0000"+ + "\u0000\u0000|\u08fb\u0001\u0000\u0000\u0000~\u0908\u0001\u0000\u0000\u0000"+ + "\u0080\u093e\u0001\u0000\u0000\u0000\u0082\u094a\u0001\u0000\u0000\u0000"+ + "\u0084\u095b\u0001\u0000\u0000\u0000\u0086\u096e\u0001\u0000\u0000\u0000"+ + "\u0088\u097e\u0001\u0000\u0000\u0000\u008a\u0987\u0001\u0000\u0000\u0000"+ + "\u008c\u09a2\u0001\u0000\u0000\u0000\u008e\u09c7\u0001\u0000\u0000\u0000"+ + "\u0090\u09cf\u0001\u0000\u0000\u0000\u0092\u09fd\u0001\u0000\u0000\u0000"+ + "\u0094\u0a3c\u0001\u0000\u0000\u0000\u0096\u0a3e\u0001\u0000\u0000\u0000"+ + "\u0098\u0a5d\u0001\u0000\u0000\u0000\u009a\u0ab0\u0001\u0000\u0000\u0000"+ + "\u009c\u0ab2\u0001\u0000\u0000\u0000\u009e\u0acb\u0001\u0000\u0000\u0000"+ + "\u00a0\u0ad2\u0001\u0000\u0000\u0000\u00a2\u0aee\u0001\u0000\u0000\u0000"+ + "\u00a4\u0b21\u0001\u0000\u0000\u0000\u00a6\u0b23\u0001\u0000\u0000\u0000"+ + "\u00a8\u0b5d\u0001\u0000\u0000\u0000\u00aa\u0b5f\u0001\u0000\u0000\u0000"+ + "\u00ac\u0b99\u0001\u0000\u0000\u0000\u00ae\u0b9b\u0001\u0000\u0000\u0000"+ + "\u00b0\u0b9d\u0001\u0000\u0000\u0000\u00b2\u0b9f\u0001\u0000\u0000\u0000"+ + "\u00b4\u0ba1\u0001\u0000\u0000\u0000\u00b6\u0ba3\u0001\u0000\u0000\u0000"+ + "\u00b8\u0ba5\u0001\u0000\u0000\u0000\u00ba\u0ba7\u0001\u0000\u0000\u0000"+ + "\u00bc\u0ba9\u0001\u0000\u0000\u0000\u00be\u0bab\u0001\u0000\u0000\u0000"+ + "\u00c0\u0bad\u0001\u0000\u0000\u0000\u00c2\u0baf\u0001\u0000\u0000\u0000"+ + "\u00c4\u0bb1\u0001\u0000\u0000\u0000\u00c6\u0bb3\u0001\u0000\u0000\u0000"+ + "\u00c8\u0bb5\u0001\u0000\u0000\u0000\u00ca\u0bb7\u0001\u0000\u0000\u0000"+ + "\u00cc\u0bde\u0001\u0000\u0000\u0000\u00ce\u0be0\u0001\u0000\u0000\u0000"+ + "\u00d0\u0be3\u0001\u0000\u0000\u0000\u00d2\u0c02\u0001\u0000\u0000\u0000"+ + "\u00d4\u0c2e\u0001\u0000\u0000\u0000\u00d6\u0c30\u0001\u0000\u0000\u0000"+ + "\u00d8\u0c3b\u0001\u0000\u0000\u0000\u00da\u0c46\u0001\u0000\u0000\u0000"+ + "\u00dc\u0c54\u0001\u0000\u0000\u0000\u00de\u0c5e\u0001\u0000\u0000\u0000"+ + "\u00e0\u0c68\u0001\u0000\u0000\u0000\u00e2\u0c70\u0001\u0000\u0000\u0000"+ + "\u00e4\u0c7a\u0001\u0000\u0000\u0000\u00e6\u0c85\u0001\u0000\u0000\u0000"+ + "\u00e8\u0c8f\u0001\u0000\u0000\u0000\u00ea\u0c9b\u0001\u0000\u0000\u0000"+ + "\u00ec\u0ca6\u0001\u0000\u0000\u0000\u00ee\u0cb0\u0001\u0000\u0000\u0000"+ + "\u00f0\u0cb8\u0001\u0000\u0000\u0000\u00f2\u0cc5\u0001\u0000\u0000\u0000"+ + "\u00f4\u0cd2\u0001\u0000\u0000\u0000\u00f6\u0cdd\u0001\u0000\u0000\u0000"+ + "\u00f8\u0cdf\u0001\u0000\u0000\u0000\u00fa\u0cec\u0001\u0000\u0000\u0000"+ + "\u00fc\u0cf9\u0001\u0000\u0000\u0000\u00fe\u0d00\u0001\u0000\u0000\u0000"+ + "\u0100\u0d0c\u0001\u0000\u0000\u0000\u0102\u0d16\u0001\u0000\u0000\u0000"+ + "\u0104\u0d1e\u0001\u0000\u0000\u0000\u0106\u0d2a\u0001\u0000\u0000\u0000"+ + "\u0108\u0d34\u0001\u0000\u0000\u0000\u010a\u0d3e\u0001\u0000\u0000\u0000"+ + "\u010c\u0d48\u0001\u0000\u0000\u0000\u010e\u0d50\u0001\u0000\u0000\u0000"+ + "\u0110\u0d5a\u0001\u0000\u0000\u0000\u0112\u0d64\u0001\u0000\u0000\u0000"+ + "\u0114\u0d6c\u0001\u0000\u0000\u0000\u0116\u0d78\u0001\u0000\u0000\u0000"+ + "\u0118\u0d84\u0001\u0000\u0000\u0000\u011a\u0d90\u0001\u0000\u0000\u0000"+ + "\u011c\u0d9c\u0001\u0000\u0000\u0000\u011e\u0da8\u0001\u0000\u0000\u0000"+ + "\u0120\u0db4\u0001\u0000\u0000\u0000\u0122\u0dbe\u0001\u0000\u0000\u0000"+ + "\u0124\u0dc6\u0001\u0000\u0000\u0000\u0126\u0dd8\u0001\u0000\u0000\u0000"+ + "\u0128\u0de2\u0001\u0000\u0000\u0000\u012a\u0dfa\u0001\u0000\u0000\u0000"+ + "\u012c\u0e07\u0001\u0000\u0000\u0000\u012e\u0e09\u0001\u0000\u0000\u0000"+ + "\u0130\u0e0b\u0001\u0000\u0000\u0000\u0132\u0e0e\u0001\u0000\u0000\u0000"+ + "\u0134\u0e4a\u0001\u0000\u0000\u0000\u0136\u0e4d\u0001\u0000\u0000\u0000"+ + "\u0138\u0e4f\u0001\u0000\u0000\u0000\u013a\u0e73\u0001\u0000\u0000\u0000"+ + "\u013c\u0e8f\u0001\u0000\u0000\u0000\u013e\u0e95\u0001\u0000\u0000\u0000"+ + "\u0140\u0ea5\u0001\u0000\u0000\u0000\u0142\u0ea9\u0001\u0000\u0000\u0000"+ + "\u0144\u0ec2\u0001\u0000\u0000\u0000\u0146\u0ec4\u0001\u0000\u0000\u0000"+ + "\u0148\u0ecd\u0001\u0000\u0000\u0000\u014a\u0ed3\u0001\u0000\u0000\u0000"+ + "\u014c\u0ed8\u0001\u0000\u0000\u0000\u014e\u0eda\u0001\u0000\u0000\u0000"+ + "\u0150\u0ede\u0001\u0000\u0000\u0000\u0152\u0ee2\u0001\u0000\u0000\u0000"+ + "\u0154\u0eec\u0001\u0000\u0000\u0000\u0156\u0eef\u0001\u0000\u0000\u0000"+ + "\u0158\u0f32\u0001\u0000\u0000\u0000\u015a\u0f6f\u0001\u0000\u0000\u0000"+ + "\u015c\u0fb3\u0001\u0000\u0000\u0000\u015e\u0fbf\u0001\u0000\u0000\u0000"+ + "\u0160\u0fe6\u0001\u0000\u0000\u0000\u0162\u0fe8\u0001\u0000\u0000\u0000"+ + "\u0164\u0ffb\u0001\u0000\u0000\u0000\u0166\u0ffd\u0001\u0000\u0000\u0000"+ + "\u0168\u1012\u0001\u0000\u0000\u0000\u016a\u1014\u0001\u0000\u0000\u0000"+ + "\u016c\u1029\u0001\u0000\u0000\u0000\u016e\u102b\u0001\u0000\u0000\u0000"+ + "\u0170\u1032\u0001\u0000\u0000\u0000\u0172\u104b\u0001\u0000\u0000\u0000"+ + "\u0174\u1051\u0001\u0000\u0000\u0000\u0176\u1070\u0001\u0000\u0000\u0000"+ + "\u0178\u1072\u0001\u0000\u0000\u0000\u017a\u10a9\u0001\u0000\u0000\u0000"+ + "\u017c\u10ac\u0001\u0000\u0000\u0000\u017e\u10d4\u0001\u0000\u0000\u0000"+ + "\u0180\u10d8\u0001\u0000\u0000\u0000\u0182\u10e1\u0001\u0000\u0000\u0000"+ + "\u0184\u10e4\u0001\u0000\u0000\u0000\u0186\u1107\u0001\u0000\u0000\u0000"+ + "\u0188\u1109\u0001\u0000\u0000\u0000\u018a\u1114\u0001\u0000\u0000\u0000"+ + "\u018c\u1125\u0001\u0000\u0000\u0000\u018e\u113d\u0001\u0000\u0000\u0000"+ + "\u0190\u1149\u0001\u0000\u0000\u0000\u0192\u114b\u0001\u0000\u0000\u0000"+ + "\u0194\u114d\u0001\u0000\u0000\u0000\u0196\u1157\u0001\u0000\u0000\u0000"+ + "\u0198\u1165\u0001\u0000\u0000\u0000\u019a\u1167\u0001\u0000\u0000\u0000"+ + "\u019c\u116e\u0001\u0000\u0000\u0000\u019e\u1185\u0001\u0000\u0000\u0000"+ + "\u01a0\u1191\u0001\u0000\u0000\u0000\u01a2\u11a6\u0001\u0000\u0000\u0000"+ + "\u01a4\u11ac\u0001\u0000\u0000\u0000\u01a6\u11b1\u0001\u0000\u0000\u0000"+ + "\u01a8\u11b9\u0001\u0000\u0000\u0000\u01aa\u11d6\u0001\u0000\u0000\u0000"+ + "\u01ac\u11e7\u0001\u0000\u0000\u0000\u01ae\u11e9\u0001\u0000\u0000\u0000"+ + "\u01b0\u1237\u0001\u0000\u0000\u0000\u01b2\u12a9\u0001\u0000\u0000\u0000"+ + "\u01b4\u12b0\u0001\u0000\u0000\u0000\u01b6\u12de\u0001\u0000\u0000\u0000"+ + "\u01b8\u12e0\u0001\u0000\u0000\u0000\u01ba\u12ec\u0001\u0000\u0000\u0000"+ + "\u01bc\u1300\u0001\u0000\u0000\u0000\u01be\u1302\u0001\u0000\u0000\u0000"+ + "\u01c0\u130a\u0001\u0000\u0000\u0000\u01c2\u1311\u0001\u0000\u0000\u0000"+ + "\u01c4\u13a9\u0001\u0000\u0000\u0000\u01c6\u13ab\u0001\u0000\u0000\u0000"+ + "\u01c8\u13b1\u0001\u0000\u0000\u0000\u01ca\u13f2\u0001\u0000\u0000\u0000"+ + "\u01cc\u13f6\u0001\u0000\u0000\u0000\u01ce\u13f8\u0001\u0000\u0000\u0000"+ + "\u01d0\u1400\u0001\u0000\u0000\u0000\u01d2\u1408\u0001\u0000\u0000\u0000"+ + "\u01d4\u140d\u0001\u0000\u0000\u0000\u01d6\u1415\u0001\u0000\u0000\u0000"+ + "\u01d8\u1419\u0001\u0000\u0000\u0000\u01da\u1425\u0001\u0000\u0000\u0000"+ + "\u01dc\u142f\u0001\u0000\u0000\u0000\u01de\u1431\u0001\u0000\u0000\u0000"+ + "\u01e0\u1457\u0001\u0000\u0000\u0000\u01e2\u1459\u0001\u0000\u0000\u0000"+ + "\u01e4\u14d1\u0001\u0000\u0000\u0000\u01e6\u14fd\u0001\u0000\u0000\u0000"+ + "\u01e8\u1514\u0001\u0000\u0000\u0000\u01ea\u1524\u0001\u0000\u0000\u0000"+ + "\u01ec\u1532\u0001\u0000\u0000\u0000\u01ee\u1559\u0001\u0000\u0000\u0000"+ + "\u01f0\u155b\u0001\u0000\u0000\u0000\u01f2\u155f\u0001\u0000\u0000\u0000"+ + "\u01f4\u1568\u0001\u0000\u0000\u0000\u01f6\u1575\u0001\u0000\u0000\u0000"+ + "\u01f8\u1583\u0001\u0000\u0000\u0000\u01fa\u15d6\u0001\u0000\u0000\u0000"+ + "\u01fc\u15d8\u0001\u0000\u0000\u0000\u01fe\u15eb\u0001\u0000\u0000\u0000"+ + "\u0200\u15ed\u0001\u0000\u0000\u0000\u0202\u15f5\u0001\u0000\u0000\u0000"+ + "\u0204\u15ff\u0001\u0000\u0000\u0000\u0206\u1601\u0001\u0000\u0000\u0000"+ + "\u0208\u1603\u0001\u0000\u0000\u0000\u020a\u1605\u0001\u0000\u0000\u0000"+ + "\u020c\u1607\u0001\u0000\u0000\u0000\u020e\u1609\u0001\u0000\u0000\u0000"+ + "\u0210\u160b\u0001\u0000\u0000\u0000\u0212\u160d\u0001\u0000\u0000\u0000"+ + "\u0214\u021d\u0003\u0002\u0001\u0000\u0215\u0216\u0005\u0343\u0000\u0000"+ + "\u0216\u0218\u0003\u0002\u0001\u0000\u0217\u0215\u0001\u0000\u0000\u0000"+ + "\u0218\u0219\u0001\u0000\u0000\u0000\u0219\u0217\u0001\u0000\u0000\u0000"+ + "\u0219\u021a\u0001\u0000\u0000\u0000\u021a\u021b\u0001\u0000\u0000\u0000"+ + "\u021b\u021c\u0005\u0343\u0000\u0000\u021c\u021e\u0001\u0000\u0000\u0000"+ + "\u021d\u0217\u0001\u0000\u0000\u0000\u021d\u021e\u0001\u0000\u0000\u0000"+ + "\u021e\u021f\u0001\u0000\u0000\u0000\u021f\u0220\u0005\u0000\u0000\u0001"+ + "\u0220\u0001\u0001\u0000\u0000\u0000\u0221\u0256\u0003\u0004\u0002\u0000"+ + "\u0222\u0256\u0003\u0006\u0003\u0000\u0223\u0256\u0003`0\u0000\u0224\u0256"+ + "\u0003n7\u0000\u0225\u0256\u0003b1\u0000\u0226\u0256\u0003d2\u0000\u0227"+ + "\u0256\u0003f3\u0000\u0228\u0256\u0003h4\u0000\u0229\u0256\u0003j5\u0000"+ + "\u022a\u0256\u0003l6\u0000\u022b\u0256\u0003\u00ccf\u0000\u022c\u0256"+ + "\u0003\u00ceg\u0000\u022d\u0256\u0003\u00d0h\u0000\u022e\u0256\u0003\u00d2"+ + "i\u0000\u022f\u0256\u0003\u00d4j\u0000\u0230\u0256\u0003\u0128\u0094\u0000"+ + "\u0231\u0256\u0003\u012a\u0095\u0000\u0232\u0256\u0003\u012c\u0096\u0000"+ + "\u0233\u0256\u0003\u012e\u0097\u0000\u0234\u0256\u0003\u0130\u0098\u0000"+ + "\u0235\u0256\u0003\u0132\u0099\u0000\u0236\u0256\u0003\u0134\u009a\u0000"+ + "\u0237\u0256\u0003\u0136\u009b\u0000\u0238\u0256\u0003\u0138\u009c\u0000"+ + "\u0239\u0256\u0003\u013a\u009d\u0000\u023a\u0256\u0003\u013c\u009e\u0000"+ + "\u023b\u0256\u0003\u013e\u009f\u0000\u023c\u0256\u0003\u0140\u00a0\u0000"+ + "\u023d\u0256\u0003\u0142\u00a1\u0000\u023e\u0256\u0003\u0144\u00a2\u0000"+ + "\u023f\u0256\u0003\u0146\u00a3\u0000\u0240\u0256\u0003\u0148\u00a4\u0000"+ + "\u0241\u0256\u0003\u014a\u00a5\u0000\u0242\u0256\u0003\u014c\u00a6\u0000"+ + "\u0243\u0256\u0003\u014e\u00a7\u0000\u0244\u0256\u0003\u0150\u00a8\u0000"+ + "\u0245\u0256\u0003\u0152\u00a9\u0000\u0246\u0256\u0003\u0154\u00aa\u0000"+ + "\u0247\u0256\u0003\u0156\u00ab\u0000\u0248\u0256\u0003\u0158\u00ac\u0000"+ + "\u0249\u0256\u0003\u015a\u00ad\u0000\u024a\u0256\u0003\u0160\u00b0\u0000"+ + "\u024b\u0256\u0003\u0162\u00b1\u0000\u024c\u0256\u0003\u0164\u00b2\u0000"+ + "\u024d\u0256\u0003\u0166\u00b3\u0000\u024e\u0256\u0003\u016c\u00b6\u0000"+ + "\u024f\u0256\u0003\u016e\u00b7\u0000\u0250\u0256\u0003\u0170\u00b8\u0000"+ + "\u0251\u0256\u0003\u0172\u00b9\u0000\u0252\u0256\u0003\u0174\u00ba\u0000"+ + "\u0253\u0256\u0003\u017a\u00bd\u0000\u0254\u0256\u0003\u017c\u00be\u0000"+ + "\u0255\u0221\u0001\u0000\u0000\u0000\u0255\u0222\u0001\u0000\u0000\u0000"+ + "\u0255\u0223\u0001\u0000\u0000\u0000\u0255\u0224\u0001\u0000\u0000\u0000"+ + "\u0255\u0225\u0001\u0000\u0000\u0000\u0255\u0226\u0001\u0000\u0000\u0000"+ + "\u0255\u0227\u0001\u0000\u0000\u0000\u0255\u0228\u0001\u0000\u0000\u0000"+ + "\u0255\u0229\u0001\u0000\u0000\u0000\u0255\u022a\u0001\u0000\u0000\u0000"+ + "\u0255\u022b\u0001\u0000\u0000\u0000\u0255\u022c\u0001\u0000\u0000\u0000"+ + "\u0255\u022d\u0001\u0000\u0000\u0000\u0255\u022e\u0001\u0000\u0000\u0000"+ + "\u0255\u022f\u0001\u0000\u0000\u0000\u0255\u0230\u0001\u0000\u0000\u0000"+ + "\u0255\u0231\u0001\u0000\u0000\u0000\u0255\u0232\u0001\u0000\u0000\u0000"+ + "\u0255\u0233\u0001\u0000\u0000\u0000\u0255\u0234\u0001\u0000\u0000\u0000"+ + "\u0255\u0235\u0001\u0000\u0000\u0000\u0255\u0236\u0001\u0000\u0000\u0000"+ + "\u0255\u0237\u0001\u0000\u0000\u0000\u0255\u0238\u0001\u0000\u0000\u0000"+ + "\u0255\u0239\u0001\u0000\u0000\u0000\u0255\u023a\u0001\u0000\u0000\u0000"+ + "\u0255\u023b\u0001\u0000\u0000\u0000\u0255\u023c\u0001\u0000\u0000\u0000"+ + "\u0255\u023d\u0001\u0000\u0000\u0000\u0255\u023e\u0001\u0000\u0000\u0000"+ + "\u0255\u023f\u0001\u0000\u0000\u0000\u0255\u0240\u0001\u0000\u0000\u0000"+ + "\u0255\u0241\u0001\u0000\u0000\u0000\u0255\u0242\u0001\u0000\u0000\u0000"+ + "\u0255\u0243\u0001\u0000\u0000\u0000\u0255\u0244\u0001\u0000\u0000\u0000"+ + "\u0255\u0245\u0001\u0000\u0000\u0000\u0255\u0246\u0001\u0000\u0000\u0000"+ + "\u0255\u0247\u0001\u0000\u0000\u0000\u0255\u0248\u0001\u0000\u0000\u0000"+ + "\u0255\u0249\u0001\u0000\u0000\u0000\u0255\u024a\u0001\u0000\u0000\u0000"+ + "\u0255\u024b\u0001\u0000\u0000\u0000\u0255\u024c\u0001\u0000\u0000\u0000"+ + "\u0255\u024d\u0001\u0000\u0000\u0000\u0255\u024e\u0001\u0000\u0000\u0000"+ + "\u0255\u024f\u0001\u0000\u0000\u0000\u0255\u0250\u0001\u0000\u0000\u0000"+ + "\u0255\u0251\u0001\u0000\u0000\u0000\u0255\u0252\u0001\u0000\u0000\u0000"+ + "\u0255\u0253\u0001\u0000\u0000\u0000\u0255\u0254\u0001\u0000\u0000\u0000"+ + "\u0256\u0003\u0001\u0000\u0000\u0000\u0257\u0258\u0003\u0202\u0101\u0000"+ + "\u0258\u0005\u0001\u0000\u0000\u0000\u0259\u0282\u0003\b\u0004\u0000\u025a"+ + "\u0282\u0003\n\u0005\u0000\u025b\u0282\u0003\f\u0006\u0000\u025c\u0282"+ + "\u0003\u000e\u0007\u0000\u025d\u0282\u0003\u0010\b\u0000\u025e\u0282\u0003"+ + "\u0012\t\u0000\u025f\u0282\u0003\u0014\n\u0000\u0260\u0282\u0003\u0016"+ + "\u000b\u0000\u0261\u0282\u0003\u0018\f\u0000\u0262\u0282\u0003\u001e\u000f"+ + "\u0000\u0263\u0282\u0003 \u0010\u0000\u0264\u0282\u0003\"\u0011\u0000"+ + "\u0265\u0282\u0003$\u0012\u0000\u0266\u0282\u0003&\u0013\u0000\u0267\u0282"+ + "\u0003(\u0014\u0000\u0268\u0282\u0003*\u0015\u0000\u0269\u0282\u0003,"+ + "\u0016\u0000\u026a\u0282\u0003.\u0017\u0000\u026b\u0282\u00030\u0018\u0000"+ + "\u026c\u0282\u00032\u0019\u0000\u026d\u0282\u00034\u001a\u0000\u026e\u0282"+ + "\u00038\u001c\u0000\u026f\u0282\u0003:\u001d\u0000\u0270\u0282\u0003<"+ + "\u001e\u0000\u0271\u0282\u0003>\u001f\u0000\u0272\u0282\u0003B!\u0000"+ + "\u0273\u0282\u0003D\"\u0000\u0274\u0282\u0003F#\u0000\u0275\u0282\u0003"+ + "H$\u0000\u0276\u0282\u0003J%\u0000\u0277\u0282\u0003L&\u0000\u0278\u0282"+ + "\u0003N\'\u0000\u0279\u0282\u0003P(\u0000\u027a\u0282\u0003R)\u0000\u027b"+ + "\u0282\u0003T*\u0000\u027c\u0282\u0003V+\u0000\u027d\u0282\u0003X,\u0000"+ + "\u027e\u0282\u0003Z-\u0000\u027f\u0282\u0003\\.\u0000\u0280\u0282\u0003"+ + "^/\u0000\u0281\u0259\u0001\u0000\u0000\u0000\u0281\u025a\u0001\u0000\u0000"+ + "\u0000\u0281\u025b\u0001\u0000\u0000\u0000\u0281\u025c\u0001\u0000\u0000"+ + "\u0000\u0281\u025d\u0001\u0000\u0000\u0000\u0281\u025e\u0001\u0000\u0000"+ + "\u0000\u0281\u025f\u0001\u0000\u0000\u0000\u0281\u0260\u0001\u0000\u0000"+ + "\u0000\u0281\u0261\u0001\u0000\u0000\u0000\u0281\u0262\u0001\u0000\u0000"+ + "\u0000\u0281\u0263\u0001\u0000\u0000\u0000\u0281\u0264\u0001\u0000\u0000"+ + "\u0000\u0281\u0265\u0001\u0000\u0000\u0000\u0281\u0266\u0001\u0000\u0000"+ + "\u0000\u0281\u0267\u0001\u0000\u0000\u0000\u0281\u0268\u0001\u0000\u0000"+ + "\u0000\u0281\u0269\u0001\u0000\u0000\u0000\u0281\u026a\u0001\u0000\u0000"+ + "\u0000\u0281\u026b\u0001\u0000\u0000\u0000\u0281\u026c\u0001\u0000\u0000"+ + "\u0000\u0281\u026d\u0001\u0000\u0000\u0000\u0281\u026e\u0001\u0000\u0000"+ + "\u0000\u0281\u026f\u0001\u0000\u0000\u0000\u0281\u0270\u0001\u0000\u0000"+ + "\u0000\u0281\u0271\u0001\u0000\u0000\u0000\u0281\u0272\u0001\u0000\u0000"+ + "\u0000\u0281\u0273\u0001\u0000\u0000\u0000\u0281\u0274\u0001\u0000\u0000"+ + "\u0000\u0281\u0275\u0001\u0000\u0000\u0000\u0281\u0276\u0001\u0000\u0000"+ + "\u0000\u0281\u0277\u0001\u0000\u0000\u0000\u0281\u0278\u0001\u0000\u0000"+ + "\u0000\u0281\u0279\u0001\u0000\u0000\u0000\u0281\u027a\u0001\u0000\u0000"+ + "\u0000\u0281\u027b\u0001\u0000\u0000\u0000\u0281\u027c\u0001\u0000\u0000"+ + "\u0000\u0281\u027d\u0001\u0000\u0000\u0000\u0281\u027e\u0001\u0000\u0000"+ + "\u0000\u0281\u027f\u0001\u0000\u0000\u0000\u0281\u0280\u0001\u0000\u0000"+ + "\u0000\u0282\u0007\u0001\u0000\u0000\u0000\u0283\u0284\u0005\u0013\u0000"+ + "\u0000\u0284\u0285\u0005\u000e\u0000\u0000\u0285\u0286\u0003\u0202\u0101"+ + "\u0000\u0286\u0287\u0005\u02ff\u0000\u0000\u0287\u0288\u0003\u01ee\u00f7"+ + "\u0000\u0288\u0289\u0005\u0300\u0000\u0000\u0289\u028a\u0005\u01d4\u0000"+ + "\u0000\u028a\u028b\u0005\u0247\u0000\u0000\u028b\u028c\u0003\u0202\u0101"+ + "\u0000\u028c\u02a2\u0001\u0000\u0000\u0000\u028d\u028e\u0005\u0013\u0000"+ + "\u0000\u028e\u028f\u0005\u000e\u0000\u0000\u028f\u0290\u0003\u0202\u0101"+ + "\u0000\u0290\u0291\u0005\u02ff\u0000\u0000\u0291\u0292\u0003\u01ee\u00f7"+ + "\u0000\u0292\u0293\u0005\u0300\u0000\u0000\u0293\u0294\u0005\u0193\u0000"+ + "\u0000\u0294\u0295\u0005\u0247\u0000\u0000\u0295\u0296\u0003\u01fa\u00fd"+ + "\u0000\u0296\u02a2\u0001\u0000\u0000\u0000\u0297\u0298\u0005\u0013\u0000"+ + "\u0000\u0298\u0299\u0005\u000e\u0000\u0000\u0299\u029a\u0003\u0202\u0101"+ + "\u0000\u029a\u029b\u0005\u02ff\u0000\u0000\u029b\u029c\u0003\u01ee\u00f7"+ + "\u0000\u029c\u029d\u0005\u0300\u0000\u0000\u029d\u029e\u0005\u0207\u0000"+ + "\u0000\u029e\u029f\u0005\u01f3\u0000\u0000\u029f\u02a0\u0003\u0202\u0101"+ + "\u0000\u02a0\u02a2\u0001\u0000\u0000\u0000\u02a1\u0283\u0001\u0000\u0000"+ + "\u0000\u02a1\u028d\u0001\u0000\u0000\u0000\u02a1\u0297\u0001\u0000\u0000"+ + "\u0000\u02a2\t\u0001\u0000\u0000\u0000\u02a3\u02a4\u0005\u0013\u0000\u0000"+ + "\u02a4\u02a5\u0005Y\u0000\u0000\u02a5\u02a6\u0003\u01cc\u00e6\u0000\u02a6"+ + "\u02a7\u0005\u01c7\u0000\u0000\u02a7\u02a8\u0005\u02b8\u0000\u0000\u02a8"+ + "\u02bf\u0001\u0000\u0000\u0000\u02a9\u02aa\u0005\u0013\u0000\u0000\u02aa"+ + "\u02ab\u0005Y\u0000\u0000\u02ab\u02ac\u0003\u01cc\u00e6\u0000\u02ac\u02ad"+ + "\u0005\u01d4\u0000\u0000\u02ad\u02ae\u0005\u0247\u0000\u0000\u02ae\u02af"+ + "\u0003\u0202\u0101\u0000\u02af\u02bf\u0001\u0000\u0000\u0000\u02b0\u02b1"+ + "\u0005\u0013\u0000\u0000\u02b1\u02b2\u0005Y\u0000\u0000\u02b2\u02b3\u0003"+ + "\u01cc\u00e6\u0000\u02b3\u02b4\u0005\u0193\u0000\u0000\u02b4\u02b5\u0005"+ + "\u0247\u0000\u0000\u02b5\u02b6\u0003\u01fa\u00fd\u0000\u02b6\u02bf\u0001"+ + "\u0000\u0000\u0000\u02b7\u02b8\u0005\u0013\u0000\u0000\u02b8\u02b9\u0005"+ + "Y\u0000\u0000\u02b9\u02ba\u0003\u01cc\u00e6\u0000\u02ba\u02bb\u0005\u0207"+ + "\u0000\u0000\u02bb\u02bc\u0005\u01f3\u0000\u0000\u02bc\u02bd\u0003\u0202"+ + "\u0101\u0000\u02bd\u02bf\u0001\u0000\u0000\u0000\u02be\u02a3\u0001\u0000"+ + "\u0000\u0000\u02be\u02a9\u0001\u0000\u0000\u0000\u02be\u02b0\u0001\u0000"+ + "\u0000\u0000\u02be\u02b7\u0001\u0000\u0000\u0000\u02bf\u000b\u0001\u0000"+ + "\u0000\u0000\u02c0\u02c1\u0005\u0013\u0000\u0000\u02c1\u02c2\u0005u\u0000"+ + "\u0000\u02c2\u02c3\u0003\u0202\u0101\u0000\u02c3\u02c4\u0005\u01d4\u0000"+ + "\u0000\u02c4\u02c5\u0005\u0247\u0000\u0000\u02c5\u02c6\u0003\u0202\u0101"+ + "\u0000\u02c6\u02d6\u0001\u0000\u0000\u0000\u02c7\u02c8\u0005\u0013\u0000"+ + "\u0000\u02c8\u02c9\u0005u\u0000\u0000\u02c9\u02ca\u0003\u0202\u0101\u0000"+ + "\u02ca\u02cb\u0005\u0193\u0000\u0000\u02cb\u02cc\u0005\u0247\u0000\u0000"+ + "\u02cc\u02cd\u0003\u01fa\u00fd\u0000\u02cd\u02d6\u0001\u0000\u0000\u0000"+ + "\u02ce\u02cf\u0005\u0013\u0000\u0000\u02cf\u02d0\u0005u\u0000\u0000\u02d0"+ + "\u02d1\u0003\u0202\u0101\u0000\u02d1\u02d2\u0005\u0207\u0000\u0000\u02d2"+ + "\u02d3\u0005\u01f3\u0000\u0000\u02d3\u02d4\u0003\u0202\u0101\u0000\u02d4"+ + "\u02d6\u0001\u0000\u0000\u0000\u02d5\u02c0\u0001\u0000\u0000\u0000\u02d5"+ + "\u02c7\u0001\u0000\u0000\u0000\u02d5\u02ce\u0001\u0000\u0000\u0000\u02d6"+ + "\r\u0001\u0000\u0000\u0000\u02d7\u02d8\u0003\u0206\u0103\u0000\u02d8\u000f"+ + "\u0001\u0000\u0000\u0000\u02d9\u02da\u0003\u0206\u0103\u0000\u02da\u0011"+ + "\u0001\u0000\u0000\u0000\u02db\u02dc\u0005\u0013\u0000\u0000\u02dc\u02dd"+ + "\u0005\u00ba\u0000\u0000\u02dd\u02e3\u0003\u0202\u0101\u0000\u02de\u02df"+ + "\u0005\u0207\u0000\u0000\u02df\u02e0\u0005\u009b\u0000\u0000\u02e0\u02e4"+ + "\u0003\u01b0\u00d8\u0000\u02e1\u02e2\u0005\u00bc\u0000\u0000\u02e2\u02e4"+ + "\u0005\u009b\u0000\u0000\u02e3\u02de\u0001\u0000\u0000\u0000\u02e3\u02e1"+ + "\u0001\u0000\u0000\u0000\u02e4\u0328\u0001\u0000\u0000\u0000\u02e5\u02e6"+ + "\u0005\u0013\u0000\u0000\u02e6\u02e7\u0005\u00ba\u0000\u0000\u02e7\u02e8"+ + "\u0003\u0202\u0101\u0000\u02e8\u02e9\u0007\u0000\u0000\u0000\u02e9\u02ea"+ + "\u0005\u016d\u0000\u0000\u02ea\u02eb\u0005\u0172\u0000\u0000\u02eb\u0328"+ + "\u0001\u0000\u0000\u0000\u02ec\u02ed\u0005\u0013\u0000\u0000\u02ed\u02ee"+ + "\u0005\u00ba\u0000\u0000\u02ee\u02ef\u0003\u0202\u0101\u0000\u02ef\u02f0"+ + "\u0005\u000b\u0000\u0000\u02f0\u02f3\u0003\u0080@\u0000\u02f1\u02f2\u0005"+ + "\u016d\u0000\u0000\u02f2\u02f4\u0005\u0274\u0000\u0000\u02f3\u02f1\u0001"+ + "\u0000\u0000\u0000\u02f3\u02f4\u0001\u0000\u0000\u0000\u02f4\u0328\u0001"+ + "\u0000\u0000\u0000\u02f5\u02f6\u0005\u0013\u0000\u0000\u02f6\u02f7\u0005"+ + "\u00ba\u0000\u0000\u02f7\u02f8\u0003\u0202\u0101\u0000\u02f8\u02f9\u0005"+ + "\u00bc\u0000\u0000\u02f9\u02fc\u0005m\u0000\u0000\u02fa\u02fb\u0005\u02b3"+ + "\u0000\u0000\u02fb\u02fd\u0005\u00d3\u0000\u0000\u02fc\u02fa\u0001\u0000"+ + "\u0000\u0000\u02fc\u02fd\u0001\u0000\u0000\u0000\u02fd\u02fe\u0001\u0000"+ + "\u0000\u0000\u02fe\u0300\u0003\u0202\u0101\u0000\u02ff\u0301\u0007\u0001"+ + "\u0000\u0000\u0300\u02ff\u0001\u0000\u0000\u0000\u0300\u0301\u0001\u0000"+ + "\u0000\u0000\u0301\u0328\u0001\u0000\u0000\u0000\u0302\u0303\u0005\u0013"+ + "\u0000\u0000\u0303\u0304\u0005\u00ba\u0000\u0000\u0304\u0305\u0003\u0202"+ + "\u0101\u0000\u0305\u0306\u0005\u01d4\u0000\u0000\u0306\u0307\u0005m\u0000"+ + "\u0000\u0307\u0308\u0003\u0202\u0101\u0000\u0308\u0309\u0005\u0247\u0000"+ + "\u0000\u0309\u030a\u0003\u0202\u0101\u0000\u030a\u0328\u0001\u0000\u0000"+ + "\u0000\u030b\u030c\u0005\u0013\u0000\u0000\u030c\u030d\u0005\u00ba\u0000"+ + "\u0000\u030d\u030e\u0003\u0202\u0101\u0000\u030e\u030f\u0005\u0275\u0000"+ + "\u0000\u030f\u0310\u0005m\u0000\u0000\u0310\u0311\u0003\u0202\u0101\u0000"+ + "\u0311\u0328\u0001\u0000\u0000\u0000\u0312\u0313\u0005\u0013\u0000\u0000"+ + "\u0313\u0314\u0005\u00ba\u0000\u0000\u0314\u0315\u0003\u0202\u0101\u0000"+ + "\u0315\u0316\u0005\u0193\u0000\u0000\u0316\u0317\u0005\u0247\u0000\u0000"+ + "\u0317\u0318\u0003\u01fa\u00fd\u0000\u0318\u0328\u0001\u0000\u0000\u0000"+ + "\u0319\u031a\u0005\u0013\u0000\u0000\u031a\u031b\u0005\u00ba\u0000\u0000"+ + "\u031b\u031c\u0003\u0202\u0101\u0000\u031c\u031d\u0005\u01d4\u0000\u0000"+ + "\u031d\u031e\u0005\u0247\u0000\u0000\u031e\u031f\u0003\u0202\u0101\u0000"+ + "\u031f\u0328\u0001\u0000\u0000\u0000\u0320\u0321\u0005\u0013\u0000\u0000"+ + "\u0321\u0322\u0005\u00ba\u0000\u0000\u0322\u0323\u0003\u0202\u0101\u0000"+ + "\u0323\u0324\u0005\u0207\u0000\u0000\u0324\u0325\u0005\u01f3\u0000\u0000"+ + "\u0325\u0326\u0003\u0202\u0101\u0000\u0326\u0328\u0001\u0000\u0000\u0000"+ + "\u0327\u02db\u0001\u0000\u0000\u0000\u0327\u02e5\u0001\u0000\u0000\u0000"+ + "\u0327\u02ec\u0001\u0000\u0000\u0000\u0327\u02f5\u0001\u0000\u0000\u0000"+ + "\u0327\u0302\u0001\u0000\u0000\u0000\u0327\u030b\u0001\u0000\u0000\u0000"+ + "\u0327\u0312\u0001\u0000\u0000\u0000\u0327\u0319\u0001\u0000\u0000\u0000"+ + "\u0327\u0320\u0001\u0000\u0000\u0000\u0328\u0013\u0001\u0000\u0000\u0000"+ + "\u0329\u032a\u0005\u0013\u0000\u0000\u032a\u032b\u0005\u02bb\u0000\u0000"+ + "\u032b\u032c\u0005\u0254\u0000\u0000\u032c\u032d\u0003\u0202\u0101\u0000"+ + "\u032d\u032e\u0005\u00b3\u0000\u0000\u032e\u034b\u0001\u0000\u0000\u0000"+ + "\u032f\u0330\u0005\u0013\u0000\u0000\u0330\u0331\u0005\u02bb\u0000\u0000"+ + "\u0331\u0332\u0005\u0254\u0000\u0000\u0332\u0333\u0003\u0202\u0101\u0000"+ + "\u0333\u0335\u0005\u00c3\u0000\u0000\u0334\u0336\u0007\u0002\u0000\u0000"+ + "\u0335\u0334\u0001\u0000\u0000\u0000\u0335\u0336\u0001\u0000\u0000\u0000"+ + "\u0336\u034b\u0001\u0000\u0000\u0000\u0337\u0338\u0005\u0013\u0000\u0000"+ + "\u0338\u0339\u0005\u02bb\u0000\u0000\u0339\u033a\u0005\u0254\u0000\u0000"+ + "\u033a\u033b\u0003\u0202\u0101\u0000\u033b\u033c\u0005\u0193\u0000\u0000"+ + "\u033c\u0340\u0005\u0247\u0000\u0000\u033d\u0341\u0003\u0202\u0101\u0000"+ + "\u033e\u0341\u0005\u008d\u0000\u0000\u033f\u0341\u0005\u0206\u0000\u0000"+ + "\u0340\u033d\u0001\u0000\u0000\u0000\u0340\u033e\u0001\u0000\u0000\u0000"+ + "\u0340\u033f\u0001\u0000\u0000\u0000\u0341\u034b\u0001\u0000\u0000\u0000"+ + "\u0342\u0343\u0005\u0013\u0000\u0000\u0343\u0344\u0005\u02bb\u0000\u0000"+ + "\u0344\u0345\u0005\u0254\u0000\u0000\u0345\u0346\u0003\u0202\u0101\u0000"+ + "\u0346\u0347\u0005\u01d4\u0000\u0000\u0347\u0348\u0005\u0247\u0000\u0000"+ + "\u0348\u0349\u0003\u0202\u0101\u0000\u0349\u034b\u0001\u0000\u0000\u0000"+ + "\u034a\u0329\u0001\u0000\u0000\u0000\u034a\u032f\u0001\u0000\u0000\u0000"+ + "\u034a\u0337\u0001\u0000\u0000\u0000\u034a\u0342\u0001\u0000\u0000\u0000"+ + "\u034b\u0015\u0001\u0000\u0000\u0000\u034c\u034d\u0005\u0013\u0000\u0000"+ + "\u034d\u034e\u0005\u00d7\u0000\u0000\u034e\u034f\u0003\u0202\u0101\u0000"+ + "\u034f\u0352\u0005\u026a\u0000\u0000\u0350\u0351\u0005\u0247\u0000\u0000"+ + "\u0351\u0353\u0003\u0202\u0101\u0000\u0352\u0350\u0001\u0000\u0000\u0000"+ + "\u0352\u0353\u0001\u0000\u0000\u0000\u0353\u035c\u0001\u0000\u0000\u0000"+ + "\u0354\u0355\u0005\u0013\u0000\u0000\u0355\u0356\u0005\u00d7\u0000\u0000"+ + "\u0356\u0357\u0003\u0202\u0101\u0000\u0357\u0358\u0005\u0207\u0000\u0000"+ + "\u0358\u0359\u0005\u01f3\u0000\u0000\u0359\u035a\u0003\u0202\u0101\u0000"+ + "\u035a\u035c\u0001\u0000\u0000\u0000\u035b\u034c\u0001\u0000\u0000\u0000"+ + "\u035b\u0354\u0001\u0000\u0000\u0000\u035c\u0017\u0001\u0000\u0000\u0000"+ + "\u035d\u035e\u0003\u0206\u0103\u0000\u035e\u0019\u0001\u0000\u0000\u0000"+ + "\u035f\u0361\u0005\u000b\u0000\u0000\u0360\u0362\u0005^\u0000\u0000\u0361"+ + "\u0360\u0001\u0000\u0000\u0000\u0361\u0362\u0001\u0000\u0000\u0000\u0362"+ + "\u0363\u0001\u0000\u0000\u0000\u0363\u0364\u0003\u020a\u0105\u0000\u0364"+ + "\u0367\u0003\u01d8\u00ec\u0000\u0365\u0366\u0005X\u0000\u0000\u0366\u0368"+ + "\u0003\u0202\u0101\u0000\u0367\u0365\u0001\u0000\u0000\u0000\u0367\u0368"+ + "\u0001\u0000\u0000\u0000\u0368\u036a\u0001\u0000\u0000\u0000\u0369\u036b"+ + "\u0003\u01f2\u00f9\u0000\u036a\u0369\u0001\u0000\u0000\u0000\u036a\u036b"+ + "\u0001\u0000\u0000\u0000\u036b\u040c\u0001\u0000\u0000\u0000\u036c\u036e"+ + "\u0005\u00bc\u0000\u0000\u036d\u036f\u0005^\u0000\u0000\u036e\u036d\u0001"+ + "\u0000\u0000\u0000\u036e\u036f\u0001\u0000\u0000\u0000\u036f\u0372\u0001"+ + "\u0000\u0000\u0000\u0370\u0371\u0005\u02b3\u0000\u0000\u0371\u0373\u0005"+ + "\u00d3\u0000\u0000\u0372\u0370\u0001\u0000\u0000\u0000\u0372\u0373\u0001"+ + "\u0000\u0000\u0000\u0373\u0374\u0001\u0000\u0000\u0000\u0374\u0376\u0003"+ + "\u020a\u0105\u0000\u0375\u0377\u0007\u0001\u0000\u0000\u0376\u0375\u0001"+ + "\u0000\u0000\u0000\u0376\u0377\u0001\u0000\u0000\u0000\u0377\u040c\u0001"+ + "\u0000\u0000\u0000\u0378\u037a\u0005\u0013\u0000\u0000\u0379\u037b\u0005"+ + "^\u0000\u0000\u037a\u0379\u0001\u0000\u0000\u0000\u037a\u037b\u0001\u0000"+ + "\u0000\u0000\u037b\u037c\u0001\u0000\u0000\u0000\u037c\u037f\u0003\u020a"+ + "\u0105\u0000\u037d\u037e\u0005\u0207\u0000\u0000\u037e\u0380\u0005\u0091"+ + "\u0000\u0000\u037f\u037d\u0001\u0000\u0000\u0000\u037f\u0380\u0001\u0000"+ + "\u0000\u0000\u0380\u0381\u0001\u0000\u0000\u0000\u0381\u0382\u0005\u025c"+ + "\u0000\u0000\u0382\u0385\u0003\u01d8\u00ec\u0000\u0383\u0384\u0005X\u0000"+ + "\u0000\u0384\u0386\u0003\u0202\u0101\u0000\u0385\u0383\u0001\u0000\u0000"+ + "\u0000\u0385\u0386\u0001\u0000\u0000\u0000\u0386\u040c\u0001\u0000\u0000"+ + "\u0000\u0387\u0389\u0005\u0013\u0000\u0000\u0388\u038a\u0005^\u0000\u0000"+ + "\u0389\u0388\u0001\u0000\u0000\u0000\u0389\u038a\u0001\u0000\u0000\u0000"+ + "\u038a\u038b\u0001\u0000\u0000\u0000\u038b\u038c\u0003\u020a\u0105\u0000"+ + "\u038c\u038d\u0005\u0207\u0000\u0000\u038d\u038e\u0005\u009b\u0000\u0000"+ + "\u038e\u038f\u0003\u01b0\u00d8\u0000\u038f\u040c\u0001\u0000\u0000\u0000"+ + "\u0390\u0392\u0005\u0013\u0000\u0000\u0391\u0393\u0005^\u0000\u0000\u0392"+ + "\u0391\u0001\u0000\u0000\u0000\u0392\u0393\u0001\u0000\u0000\u0000\u0393"+ + "\u0394\u0001\u0000\u0000\u0000\u0394\u0395\u0003\u020a\u0105\u0000\u0395"+ + "\u0396\u0005\u00bc\u0000\u0000\u0396\u0397\u0005\u009b\u0000\u0000\u0397"+ + "\u040c\u0001\u0000\u0000\u0000\u0398\u039a\u0005\u0013\u0000\u0000\u0399"+ + "\u039b\u0005^\u0000\u0000\u039a\u0399\u0001\u0000\u0000\u0000\u039a\u039b"+ + "\u0001\u0000\u0000\u0000\u039b\u039c\u0001\u0000\u0000\u0000\u039c\u039d"+ + "\u0003\u020a\u0105\u0000\u039d\u039e\u0007\u0000\u0000\u0000\u039e\u039f"+ + "\u0005\u016d\u0000\u0000\u039f\u03a0\u0005\u0172\u0000\u0000\u03a0\u040c"+ + "\u0001\u0000\u0000\u0000\u03a1\u03a3\u0005\u0013\u0000\u0000\u03a2\u03a4"+ + "\u0005^\u0000\u0000\u03a3\u03a2\u0001\u0000\u0000\u0000\u03a3\u03a4\u0001"+ + "\u0000\u0000\u0000\u03a4\u03a5\u0001\u0000\u0000\u0000\u03a5\u03a6\u0003"+ + "\u020a\u0105\u0000\u03a6\u03a7\u0005\u0207\u0000\u0000\u03a7\u03a8\u0005"+ + "\u0224\u0000\u0000\u03a8\u03a9\u0005\u011b\u0000\u0000\u03a9\u040c\u0001"+ + "\u0000\u0000\u0000\u03aa\u03ac\u0005\u0013\u0000\u0000\u03ab\u03ad\u0005"+ + "^\u0000\u0000\u03ac\u03ab\u0001\u0000\u0000\u0000\u03ac\u03ad\u0001\u0000"+ + "\u0000\u0000\u03ad\u03ae\u0001\u0000\u0000\u0000\u03ae\u03af\u0003\u020a"+ + "\u0105\u0000\u03af\u03b0\u0005\u0207\u0000\u0000\u03b0\u03b1\u0005\u02ff"+ + "\u0000\u0000\u03b1\u03b2\u0003\u01d4\u00ea\u0000\u03b2\u03b3\u0005\u0300"+ + "\u0000\u0000\u03b3\u040c\u0001\u0000\u0000\u0000\u03b4\u03b6\u0005\u0013"+ + "\u0000\u0000\u03b5\u03b7\u0005^\u0000\u0000\u03b6\u03b5\u0001\u0000\u0000"+ + "\u0000\u03b6\u03b7\u0001\u0000\u0000\u0000\u03b7\u03b8\u0001\u0000\u0000"+ + "\u0000\u03b8\u03b9\u0003\u020a\u0105\u0000\u03b9\u03ba\u0005\u01d8\u0000"+ + "\u0000\u03ba\u03bb\u0005\u02ff\u0000\u0000\u03bb\u03bc\u0003\u01d0\u00e8"+ + "\u0000\u03bc\u03bd\u0005\u0300\u0000\u0000\u03bd\u040c\u0001\u0000\u0000"+ + "\u0000\u03be\u03c0\u0005\u0013\u0000\u0000\u03bf\u03c1\u0005^\u0000\u0000"+ + "\u03c0\u03bf\u0001\u0000\u0000\u0000\u03c0\u03c1\u0001\u0000\u0000\u0000"+ + "\u03c1\u03c2\u0001\u0000\u0000\u0000\u03c2\u03c3\u0003\u020a\u0105\u0000"+ + "\u03c3\u03c4\u0005\u0207\u0000\u0000\u03c4\u03c5\u0005\u0229\u0000\u0000"+ + "\u03c5\u03c6\u0007\u0003\u0000\u0000\u03c6\u040c\u0001\u0000\u0000\u0000"+ + "\u03c7\u03c9\u0005\u0013\u0000\u0000\u03c8\u03ca\u0005^\u0000\u0000\u03c9"+ + "\u03c8\u0001\u0000\u0000\u0000\u03c9\u03ca\u0001\u0000\u0000\u0000\u03ca"+ + "\u03cb\u0001\u0000\u0000\u0000\u03cb\u03cc\u0003\u020a\u0105\u0000\u03cc"+ + "\u03ce\u0005\u0186\u0000\u0000\u03cd\u03cf\u0007\u0004\u0000\u0000\u03ce"+ + "\u03cd\u0001\u0000\u0000\u0000\u03ce\u03cf\u0001\u0000\u0000\u0000\u03cf"+ + "\u040c\u0001\u0000\u0000\u0000\u03d0\u03d1\u0005\u000b\u0000\u0000\u03d1"+ + "\u03d4\u0003\u01f8\u00fc\u0000\u03d2\u03d3\u0005\u016d\u0000\u0000\u03d3"+ + "\u03d5\u0005\u0274\u0000\u0000\u03d4\u03d2\u0001\u0000\u0000\u0000\u03d4"+ + "\u03d5\u0001\u0000\u0000\u0000\u03d5\u040c\u0001\u0000\u0000\u0000\u03d6"+ + "\u03d7\u0005\u0275\u0000\u0000\u03d7\u03d8\u0005m\u0000\u0000\u03d8\u040c"+ + "\u0003\u0204\u0102\u0000\u03d9\u03da\u0005\u00bc\u0000\u0000\u03da\u03dd"+ + "\u0005m\u0000\u0000\u03db\u03dc\u0005\u02b3\u0000\u0000\u03dc\u03de\u0005"+ + "\u00d3\u0000\u0000\u03dd\u03db\u0001\u0000\u0000\u0000\u03dd\u03de\u0001"+ + "\u0000\u0000\u0000\u03de\u03df\u0001\u0000\u0000\u0000\u03df\u03e1\u0003"+ + "\u0204\u0102\u0000\u03e0\u03e2\u0007\u0001\u0000\u0000\u03e1\u03e0\u0001"+ + "\u0000\u0000\u0000\u03e1\u03e2\u0001\u0000\u0000\u0000\u03e2\u040c\u0001"+ + "\u0000\u0000\u0000\u03e3\u03e4\u0005\u00b3\u0000\u0000\u03e4\u03e8\u0005"+ + "\u0254\u0000\u0000\u03e5\u03e9\u0003\u0204\u0102\u0000\u03e6\u03e9\u0005"+ + "\u0010\u0000\u0000\u03e7\u03e9\u0005\u026d\u0000\u0000\u03e8\u03e5\u0001"+ + "\u0000\u0000\u0000\u03e8\u03e6\u0001\u0000\u0000\u0000\u03e8\u03e7\u0001"+ + "\u0000\u0000\u0000\u03e8\u03e9\u0001\u0000\u0000\u0000\u03e9\u040c\u0001"+ + "\u0000\u0000\u0000\u03ea\u03eb\u0005\u00c3\u0000\u0000\u03eb\u03ef\u0005"+ + "\u0254\u0000\u0000\u03ec\u03f0\u0003\u0204\u0102\u0000\u03ed\u03f0\u0005"+ + "\u0010\u0000\u0000\u03ee\u03f0\u0005\u026d\u0000\u0000\u03ef\u03ec\u0001"+ + "\u0000\u0000\u0000\u03ef\u03ed\u0001\u0000\u0000\u0000\u03ef\u03ee\u0001"+ + "\u0000\u0000\u0000\u03ef\u03f0\u0001\u0000\u0000\u0000\u03f0\u040c\u0001"+ + "\u0000\u0000\u0000\u03f1\u03f2\u0005\u00c3\u0000\u0000\u03f2\u03f3\u0005"+ + "\u01d7\u0000\u0000\u03f3\u03f4\u0005\u0254\u0000\u0000\u03f4\u040c\u0003"+ + "\u0204\u0102\u0000\u03f5\u03f6\u0005\u00c3\u0000\u0000\u03f6\u03f7\u0005"+ + "\u0014\u0000\u0000\u03f7\u03f8\u0005\u0254\u0000\u0000\u03f8\u040c\u0003"+ + "\u0204\u0102\u0000\u03f9\u03fa\u0005\u0207\u0000\u0000\u03fa\u03fb\u0005"+ + "\u0287\u0000\u0000\u03fb\u040c\u0005\u017e\u0000\u0000\u03fc\u03fd\u0005"+ + "\u0207\u0000\u0000\u03fd\u03fe\u0005\u0289\u0000\u0000\u03fe\u040c\u0005"+ + "\u017e\u0000\u0000\u03ff\u0400\u0005\u0294\u0000\u0000\u0400\u040c\u0003"+ + "\u0202\u0101\u0000\u0401\u0402\u0005\u0167\u0000\u0000\u0402\u0403\u0005"+ + "\u0294\u0000\u0000\u0403\u040c\u0003\u0202\u0101\u0000\u0404\u0405\u0005"+ + "\u0193\u0000\u0000\u0405\u0406\u0005\u0247\u0000\u0000\u0406\u040c\u0003"+ + "\u01fa\u00fd\u0000\u0407\u0409\u0005\u0186\u0000\u0000\u0408\u040a\u0007"+ + "\u0004\u0000\u0000\u0409\u0408\u0001\u0000\u0000\u0000\u0409\u040a\u0001"+ + "\u0000\u0000\u0000\u040a\u040c\u0001\u0000\u0000\u0000\u040b\u035f\u0001"+ + "\u0000\u0000\u0000\u040b\u036c\u0001\u0000\u0000\u0000\u040b\u0378\u0001"+ + "\u0000\u0000\u0000\u040b\u0387\u0001\u0000\u0000\u0000\u040b\u0390\u0001"+ + "\u0000\u0000\u0000\u040b\u0398\u0001\u0000\u0000\u0000\u040b\u03a1\u0001"+ + "\u0000\u0000\u0000\u040b\u03aa\u0001\u0000\u0000\u0000\u040b\u03b4\u0001"+ + "\u0000\u0000\u0000\u040b\u03be\u0001\u0000\u0000\u0000\u040b\u03c7\u0001"+ + "\u0000\u0000\u0000\u040b\u03d0\u0001\u0000\u0000\u0000\u040b\u03d6\u0001"+ + "\u0000\u0000\u0000\u040b\u03d9\u0001\u0000\u0000\u0000\u040b\u03e3\u0001"+ + "\u0000\u0000\u0000\u040b\u03ea\u0001\u0000\u0000\u0000\u040b\u03f1\u0001"+ + "\u0000\u0000\u0000\u040b\u03f5\u0001\u0000\u0000\u0000\u040b\u03f9\u0001"+ + "\u0000\u0000\u0000\u040b\u03fc\u0001\u0000\u0000\u0000\u040b\u03ff\u0001"+ + "\u0000\u0000\u0000\u040b\u0401\u0001\u0000\u0000\u0000\u040b\u0404\u0001"+ + "\u0000\u0000\u0000\u040b\u0407\u0001\u0000\u0000\u0000\u040c\u001b\u0001"+ + "\u0000\u0000\u0000\u040d\u0412\u0003\u001a\r\u0000\u040e\u040f\u0005\u02f9"+ + "\u0000\u0000\u040f\u0411\u0003\u001a\r\u0000\u0410\u040e\u0001\u0000\u0000"+ + "\u0000\u0411\u0414\u0001\u0000\u0000\u0000\u0412\u0410\u0001\u0000\u0000"+ + "\u0000\u0412\u0413\u0001\u0000\u0000\u0000\u0413\u001d\u0001\u0000\u0000"+ + "\u0000\u0414\u0412\u0001\u0000\u0000\u0000\u0415\u0416\u0005\u0013\u0000"+ + "\u0000\u0416\u0417\u0005\u00e5\u0000\u0000\u0417\u041a\u0005\u0237\u0000"+ + "\u0000\u0418\u0419\u0005\u02b3\u0000\u0000\u0419\u041b\u0005\u00d3\u0000"+ + "\u0000\u041a\u0418\u0001\u0000\u0000\u0000\u041a\u041b\u0001\u0000\u0000"+ + "\u0000\u041b\u041d\u0001\u0000\u0000\u0000\u041c\u041e\u0005\u0181\u0000"+ + "\u0000\u041d\u041c\u0001\u0000\u0000\u0000\u041d\u041e\u0001\u0000\u0000"+ + "\u0000\u041e\u041f\u0001\u0000\u0000\u0000\u041f\u0421\u0003\u0202\u0101"+ + "\u0000\u0420\u0422\u0005\u02fe\u0000\u0000\u0421\u0420\u0001\u0000\u0000"+ + "\u0000\u0421\u0422\u0001\u0000\u0000\u0000\u0422\u0423\u0001\u0000\u0000"+ + "\u0000\u0423\u0424\u0003\u001c\u000e\u0000\u0424\u0454\u0001\u0000\u0000"+ + "\u0000\u0425\u0426\u0005\u0013\u0000\u0000\u0426\u0427\u0005\u00e5\u0000"+ + "\u0000\u0427\u042a\u0005\u0237\u0000\u0000\u0428\u0429\u0005\u02b3\u0000"+ + "\u0000\u0429\u042b\u0005\u00d3\u0000\u0000\u042a\u0428\u0001\u0000\u0000"+ + "\u0000\u042a\u042b\u0001\u0000\u0000\u0000\u042b\u042d\u0001\u0000\u0000"+ + "\u0000\u042c\u042e\u0005\u0181\u0000\u0000\u042d\u042c\u0001\u0000\u0000"+ + "\u0000\u042d\u042e\u0001\u0000\u0000\u0000\u042e\u042f\u0001\u0000\u0000"+ + "\u0000\u042f\u0431\u0003\u0202\u0101\u0000\u0430\u0432\u0005\u02fe\u0000"+ + "\u0000\u0431\u0430\u0001\u0000\u0000\u0000\u0431\u0432\u0001\u0000\u0000"+ + "\u0000\u0432\u0433\u0001\u0000\u0000\u0000\u0433\u0435\u0005\u01d4\u0000"+ + "\u0000\u0434\u0436\u0005^\u0000\u0000\u0435\u0434\u0001\u0000\u0000\u0000"+ + "\u0435\u0436\u0001\u0000\u0000\u0000\u0436\u0437\u0001\u0000\u0000\u0000"+ + "\u0437\u0438\u0003\u020a\u0105\u0000\u0438\u0439\u0005\u0247\u0000\u0000"+ + "\u0439\u043a\u0003\u0202\u0101\u0000\u043a\u0454\u0001\u0000\u0000\u0000"+ + "\u043b\u043c\u0005\u0013\u0000\u0000\u043c\u043d\u0005\u00e5\u0000\u0000"+ + "\u043d\u0440\u0005\u0237\u0000\u0000\u043e\u043f\u0005\u02b3\u0000\u0000"+ + "\u043f\u0441\u0005\u00d3\u0000\u0000\u0440\u043e\u0001\u0000\u0000\u0000"+ + "\u0440\u0441\u0001\u0000\u0000\u0000\u0441\u0442\u0001\u0000\u0000\u0000"+ + "\u0442\u0443\u0003\u0202\u0101\u0000\u0443\u0444\u0005\u01d4\u0000\u0000"+ + "\u0444\u0445\u0005\u0247\u0000\u0000\u0445\u0446\u0003\u0202\u0101\u0000"+ + "\u0446\u0454\u0001\u0000\u0000\u0000\u0447\u0448\u0005\u0013\u0000\u0000"+ + "\u0448\u0449\u0005\u00e5\u0000\u0000\u0449\u044c\u0005\u0237\u0000\u0000"+ + "\u044a\u044b\u0005\u02b3\u0000\u0000\u044b\u044d\u0005\u00d3\u0000\u0000"+ + "\u044c\u044a\u0001\u0000\u0000\u0000\u044c\u044d\u0001\u0000\u0000\u0000"+ + "\u044d\u044e\u0001\u0000\u0000\u0000\u044e\u044f\u0003\u0202\u0101\u0000"+ + "\u044f\u0450\u0005\u0207\u0000\u0000\u0450\u0451\u0005\u01f3\u0000\u0000"+ + "\u0451\u0452\u0003\u0202\u0101\u0000\u0452\u0454\u0001\u0000\u0000\u0000"+ + "\u0453\u0415\u0001\u0000\u0000\u0000\u0453\u0425\u0001\u0000\u0000\u0000"+ + "\u0453\u043b\u0001\u0000\u0000\u0000\u0453\u0447\u0001\u0000\u0000\u0000"+ + "\u0454\u001f\u0001\u0000\u0000\u0000\u0455\u0456\u0003\u0206\u0103\u0000"+ + "\u0456!\u0001\u0000\u0000\u0000\u0457\u0458\u0005\u0013\u0000\u0000\u0458"+ + "\u0459\u0005\u00fa\u0000\u0000\u0459\u045a\u0003\u01fa\u00fd\u0000\u045a"+ + "\u045b\u0005\u000b\u0000\u0000\u045b\u045c\u0005\u026d\u0000\u0000\u045c"+ + "\u045d\u0003\u01d0\u00e8\u0000\u045d\u046d\u0001\u0000\u0000\u0000\u045e"+ + "\u045f\u0005\u0013\u0000\u0000\u045f\u0460\u0005\u00fa\u0000\u0000\u0460"+ + "\u0461\u0003\u01fa\u00fd\u0000\u0461\u0462\u0005\u00bc\u0000\u0000\u0462"+ + "\u0463\u0005\u026d\u0000\u0000\u0463\u0464\u0003\u01d0\u00e8\u0000\u0464"+ + "\u046d\u0001\u0000\u0000\u0000\u0465\u0466\u0005\u0013\u0000\u0000\u0466"+ + "\u0467\u0005\u00fa\u0000\u0000\u0467\u0468\u0003\u0202\u0101\u0000\u0468"+ + "\u0469\u0005\u01d4\u0000\u0000\u0469\u046a\u0005\u0247\u0000\u0000\u046a"+ + "\u046b\u0003\u0202\u0101\u0000\u046b\u046d\u0001\u0000\u0000\u0000\u046c"+ + "\u0457\u0001\u0000\u0000\u0000\u046c\u045e\u0001\u0000\u0000\u0000\u046c"+ + "\u0465\u0001\u0000\u0000\u0000\u046d#\u0001\u0000\u0000\u0000\u046e\u046f"+ + "\u0005\u0013\u0000\u0000\u046f\u0472\u0005\u010c\u0000\u0000\u0470\u0471"+ + "\u0005\u02b3\u0000\u0000\u0471\u0473\u0005\u00d3\u0000\u0000\u0472\u0470"+ + "\u0001\u0000\u0000\u0000\u0472\u0473\u0001\u0000\u0000\u0000\u0473\u0474"+ + "\u0001\u0000\u0000\u0000\u0474\u0475\u0003\u0202\u0101\u0000\u0475\u0476"+ + "\u0005\u01d4\u0000\u0000\u0476\u0477\u0005\u0247\u0000\u0000\u0477\u0478"+ + "\u0003\u0202\u0101\u0000\u0478\u04b5\u0001\u0000\u0000\u0000\u0479\u047a"+ + "\u0005\u0013\u0000\u0000\u047a\u047d\u0005\u010c\u0000\u0000\u047b\u047c"+ + "\u0005\u02b3\u0000\u0000\u047c\u047e\u0005\u00d3\u0000\u0000\u047d\u047b"+ + "\u0001\u0000\u0000\u0000\u047d\u047e\u0001\u0000\u0000\u0000\u047e\u047f"+ + "\u0001\u0000\u0000\u0000\u047f\u0480\u0003\u0202\u0101\u0000\u0480\u0481"+ + "\u0005\u0207\u0000\u0000\u0481\u0482\u0005\u023a\u0000\u0000\u0482\u0483"+ + "\u0003\u0202\u0101\u0000\u0483\u04b5\u0001\u0000\u0000\u0000\u0484\u0485"+ + "\u0005\u0013\u0000\u0000\u0485\u0486\u0005\u010c\u0000\u0000\u0486\u0487"+ + "\u0003\u0202\u0101\u0000\u0487\u0488\u0005\u00a7\u0000\u0000\u0488\u0489"+ + "\u0005\u0180\u0000\u0000\u0489\u048a\u0005\u00d7\u0000\u0000\u048a\u048b"+ + "\u0003\u0202\u0101\u0000\u048b\u04b5\u0001\u0000\u0000\u0000\u048c\u048d"+ + "\u0005\u0013\u0000\u0000\u048d\u0490\u0005\u010c\u0000\u0000\u048e\u048f"+ + "\u0005\u02b3\u0000\u0000\u048f\u0491\u0005\u00d3\u0000\u0000\u0490\u048e"+ + "\u0001\u0000\u0000\u0000\u0490\u0491\u0001\u0000\u0000\u0000\u0491\u0492"+ + "\u0001\u0000\u0000\u0000\u0492\u0493\u0003\u0202\u0101\u0000\u0493\u0494"+ + "\u0005\u0207\u0000\u0000\u0494\u0495\u0005\u02ff\u0000\u0000\u0495\u0496"+ + "\u0003\u01d4\u00ea\u0000\u0496\u0497\u0005\u0300\u0000\u0000\u0497\u04b5"+ + "\u0001\u0000\u0000\u0000\u0498\u0499\u0005\u0013\u0000\u0000\u0499\u049c"+ + "\u0005\u010c\u0000\u0000\u049a\u049b\u0005\u02b3\u0000\u0000\u049b\u049d"+ + "\u0005\u00d3\u0000\u0000\u049c\u049a\u0001\u0000\u0000\u0000\u049c\u049d"+ + "\u0001\u0000\u0000\u0000\u049d\u049e\u0001\u0000\u0000\u0000\u049e\u049f"+ + "\u0005\u01d8\u0000\u0000\u049f\u04a0\u0005\u02ff\u0000\u0000\u04a0\u04a1"+ + "\u0003\u01d0\u00e8\u0000\u04a1\u04a2\u0005\u0300\u0000\u0000\u04a2\u04b5"+ + "\u0001\u0000\u0000\u0000\u04a3\u04a4\u0005\u0013\u0000\u0000\u04a4\u04a5"+ + "\u0005\u010c\u0000\u0000\u04a5\u04a6\u0005\u0010\u0000\u0000\u04a6\u04a7"+ + "\u0005\u0109\u0000\u0000\u04a7\u04a8\u0005\u023a\u0000\u0000\u04a8\u04ac"+ + "\u0003\u0202\u0101\u0000\u04a9\u04aa\u0005\u02cf\u0000\u0000\u04aa\u04ab"+ + "\u00056\u0000\u0000\u04ab\u04ad\u0003\u01d0\u00e8\u0000\u04ac\u04a9\u0001"+ + "\u0000\u0000\u0000\u04ac\u04ad\u0001\u0000\u0000\u0000\u04ad\u04ae\u0001"+ + "\u0000\u0000\u0000\u04ae\u04af\u0005\u0207\u0000\u0000\u04af\u04b0\u0005"+ + "\u023a\u0000\u0000\u04b0\u04b2\u0003\u0202\u0101\u0000\u04b1\u04b3\u0005"+ + "\u0171\u0000\u0000\u04b2\u04b1\u0001\u0000\u0000\u0000\u04b2\u04b3\u0001"+ + "\u0000\u0000\u0000\u04b3\u04b5\u0001\u0000\u0000\u0000\u04b4\u046e\u0001"+ + "\u0000\u0000\u0000\u04b4\u0479\u0001\u0000\u0000\u0000\u04b4\u0484\u0001"+ + "\u0000\u0000\u0000\u04b4\u048c\u0001\u0000\u0000\u0000\u04b4\u0498\u0001"+ + "\u0000\u0000\u0000\u04b4\u04a3\u0001\u0000\u0000\u0000\u04b5%\u0001\u0000"+ + "\u0000\u0000\u04b6\u04b8\u0005\u0013\u0000\u0000\u04b7\u04b9\u0005\u01b7"+ + "\u0000\u0000\u04b8\u04b7\u0001\u0000\u0000\u0000\u04b8\u04b9\u0001\u0000"+ + "\u0000\u0000\u04b9\u04ba\u0001\u0000\u0000\u0000\u04ba\u04bb\u0005\u012b"+ + "\u0000\u0000\u04bb\u04bc\u0003\u0202\u0101\u0000\u04bc\u04bd\u0005\u01d4"+ + "\u0000\u0000\u04bd\u04be\u0005\u0247\u0000\u0000\u04be\u04bf\u0003\u0202"+ + "\u0101\u0000\u04bf\u04ce\u0001\u0000\u0000\u0000\u04c0\u04c2\u0005\u0013"+ + "\u0000\u0000\u04c1\u04c3\u0005\u01b7\u0000\u0000\u04c2\u04c1\u0001\u0000"+ + "\u0000\u0000\u04c2\u04c3\u0001\u0000\u0000\u0000\u04c3\u04c4\u0001\u0000"+ + "\u0000\u0000\u04c4\u04c5\u0005\u012b\u0000\u0000\u04c5\u04c6\u0003\u0202"+ + "\u0101\u0000\u04c6\u04c7\u0005\u0193\u0000\u0000\u04c7\u04cb\u0005\u0247"+ + "\u0000\u0000\u04c8\u04cc\u0003\u0202\u0101\u0000\u04c9\u04cc\u0005\u008d"+ + "\u0000\u0000\u04ca\u04cc\u0005\u0206\u0000\u0000\u04cb\u04c8\u0001\u0000"+ + "\u0000\u0000\u04cb\u04c9\u0001\u0000\u0000\u0000\u04cb\u04ca\u0001\u0000"+ + "\u0000\u0000\u04cc\u04ce\u0001\u0000\u0000\u0000\u04cd\u04b6\u0001\u0000"+ + "\u0000\u0000\u04cd\u04c0\u0001\u0000\u0000\u0000\u04ce\'\u0001\u0000\u0000"+ + "\u0000\u04cf\u04d0\u0005\u0013\u0000\u0000\u04d0\u04d1\u0005\u012c\u0000"+ + "\u0000\u04d1\u04d2\u0005\u0178\u0000\u0000\u04d2\u04d3\u0005\u0306\u0000"+ + "\u0000\u04d3\u04d4\u0005\u0193\u0000\u0000\u04d4\u04d8\u0005\u0247\u0000"+ + "\u0000\u04d5\u04d9\u0003\u0202\u0101\u0000\u04d6\u04d9\u0005\u008d\u0000"+ + "\u0000\u04d7\u04d9\u0005\u0206\u0000\u0000\u04d8\u04d5\u0001\u0000\u0000"+ + "\u0000\u04d8\u04d6\u0001\u0000\u0000\u0000\u04d8\u04d7\u0001\u0000\u0000"+ + "\u0000\u04d9)\u0001\u0000\u0000\u0000\u04da\u04db\u0003\u0206\u0103\u0000"+ + "\u04db+\u0001\u0000\u0000\u0000\u04dc\u04dd\u0003\u0206\u0103\u0000\u04dd"+ + "-\u0001\u0000\u0000\u0000\u04de\u04df\u0005\u0013\u0000\u0000\u04df\u04e0"+ + "\u0005\u0184\u0000\u0000\u04e0\u04e1\u0005Q\u0000\u0000\u04e1\u04e2\u0003"+ + "\u0202\u0101\u0000\u04e2\u04e3\u0005\u0272\u0000\u0000\u04e3\u04e4\u0003"+ + "\u01dc\u00ee\u0000\u04e4\u04e5\u0005\u01d4\u0000\u0000\u04e5\u04e6\u0005"+ + "\u0247\u0000\u0000\u04e6\u04e7\u0003\u0202\u0101\u0000\u04e7\u0500\u0001"+ + "\u0000\u0000\u0000\u04e8\u04e9\u0005\u0013\u0000\u0000\u04e9\u04ea\u0005"+ + "\u0184\u0000\u0000\u04ea\u04eb\u0005Q\u0000\u0000\u04eb\u04ec\u0003\u0202"+ + "\u0101\u0000\u04ec\u04ed\u0005\u0272\u0000\u0000\u04ed\u04ee\u0003\u01dc"+ + "\u00ee\u0000\u04ee\u04ef\u0005\u0193\u0000\u0000\u04ef\u04f3\u0005\u0247"+ + "\u0000\u0000\u04f0\u04f4\u0003\u0202\u0101\u0000\u04f1\u04f4\u0005\u008d"+ + "\u0000\u0000\u04f2\u04f4\u0005\u0206\u0000\u0000\u04f3\u04f0\u0001\u0000"+ + "\u0000\u0000\u04f3\u04f1\u0001\u0000\u0000\u0000\u04f3\u04f2\u0001\u0000"+ + "\u0000\u0000\u04f4\u0500\u0001\u0000\u0000\u0000\u04f5\u04f6\u0005\u0013"+ + "\u0000\u0000\u04f6\u04f7\u0005\u0184\u0000\u0000\u04f7\u04f8\u0005Q\u0000"+ + "\u0000\u04f8\u04f9\u0003\u0202\u0101\u0000\u04f9\u04fa\u0005\u0272\u0000"+ + "\u0000\u04fa\u04fb\u0003\u01dc\u00ee\u0000\u04fb\u04fc\u0005\u0207\u0000"+ + "\u0000\u04fc\u04fd\u0005\u01f3\u0000\u0000\u04fd\u04fe\u0003\u0202\u0101"+ + "\u0000\u04fe\u0500\u0001\u0000\u0000\u0000\u04ff\u04de\u0001\u0000\u0000"+ + "\u0000\u04ff\u04e8\u0001\u0000\u0000\u0000\u04ff\u04f5\u0001\u0000\u0000"+ + "\u0000\u0500/\u0001\u0000\u0000\u0000\u0501\u0502\u0003\u0206\u0103\u0000"+ + "\u05021\u0001\u0000\u0000\u0000\u0503\u0504\u0005\u0013\u0000\u0000\u0504"+ + "\u0505\u0005\u02ce\u0000\u0000\u0505\u0506\u0003\u0202\u0101\u0000\u0506"+ + "\u0507\u0005\u0180\u0000\u0000\u0507\u0508\u0003\u0202\u0101\u0000\u0508"+ + "\u0509\u0005\u01d4\u0000\u0000\u0509\u050a\u0005\u0247\u0000\u0000\u050a"+ + "\u050b\u0003\u0202\u0101\u0000\u050b\u051f\u0001\u0000\u0000\u0000\u050c"+ + "\u050d\u0005\u0013\u0000\u0000\u050d\u050e\u0005\u02ce\u0000\u0000\u050e"+ + "\u050f\u0003\u0202\u0101\u0000\u050f\u0510\u0005\u0180\u0000\u0000\u0510"+ + "\u0513\u0003\u0202\u0101\u0000\u0511\u0512\u0005\u0247\u0000\u0000\u0512"+ + "\u0514\u0003\u01fc\u00fe\u0000\u0513\u0511\u0001\u0000\u0000\u0000\u0513"+ + "\u0514\u0001\u0000\u0000\u0000\u0514\u0517\u0001\u0000\u0000\u0000\u0515"+ + "\u0516\u0005\u0272\u0000\u0000\u0516\u0518\u0003\u01ec\u00f6\u0000\u0517"+ + "\u0515\u0001\u0000\u0000\u0000\u0517\u0518\u0001\u0000\u0000\u0000\u0518"+ + "\u051c\u0001\u0000\u0000\u0000\u0519\u051a\u0005\u0287\u0000\u0000\u051a"+ + "\u051b\u0005N\u0000\u0000\u051b\u051d\u0003\u01ec\u00f6\u0000\u051c\u0519"+ + "\u0001\u0000\u0000\u0000\u051c\u051d\u0001\u0000\u0000\u0000\u051d\u051f"+ + "\u0001\u0000\u0000\u0000\u051e\u0503\u0001\u0000\u0000\u0000\u051e\u050c"+ + "\u0001\u0000\u0000\u0000\u051f3\u0001\u0000\u0000\u0000\u0520\u0521\u0005"+ + "\u0013\u0000\u0000\u0521\u0522\u0005\u01ba\u0000\u0000\u0522\u0523\u0003"+ + "\u0202\u0101\u0000\u0523\u0524\u0005\u000b\u0000\u0000\u0524\u0526\u0005"+ + "\u0237\u0000\u0000\u0525\u0527\u0005\u0181\u0000\u0000\u0526\u0525\u0001"+ + "\u0000\u0000\u0000\u0526\u0527\u0001\u0000\u0000\u0000\u0527\u0528\u0001"+ + "\u0000\u0000\u0000\u0528\u0529\u0003\u01d0\u00e8\u0000\u0529\u0555\u0001"+ + "\u0000\u0000\u0000\u052a\u052b\u0005\u0013\u0000\u0000\u052b\u052c\u0005"+ + "\u01ba\u0000\u0000\u052c\u052d\u0003\u0202\u0101\u0000\u052d\u052e\u0005"+ + "\u0207\u0000\u0000\u052e\u0530\u0005\u0237\u0000\u0000\u052f\u0531\u0005"+ + "\u0181\u0000\u0000\u0530\u052f\u0001\u0000\u0000\u0000\u0530\u0531\u0001"+ + "\u0000\u0000\u0000\u0531\u0532\u0001\u0000\u0000\u0000\u0532\u0533\u0003"+ + "\u01d0\u00e8\u0000\u0533\u0555\u0001\u0000\u0000\u0000\u0534\u0535\u0005"+ + "\u0013\u0000\u0000\u0535\u0536\u0005\u01ba\u0000\u0000\u0536\u0537\u0003"+ + "\u0202\u0101\u0000\u0537\u0538\u0005\u00bc\u0000\u0000\u0538\u053a\u0005"+ + "\u0237\u0000\u0000\u0539\u053b\u0005\u0181\u0000\u0000\u053a\u0539\u0001"+ + "\u0000\u0000\u0000\u053a\u053b\u0001\u0000\u0000\u0000\u053b\u053c\u0001"+ + "\u0000\u0000\u0000\u053c\u053d\u0003\u01d0\u00e8\u0000\u053d\u0555\u0001"+ + "\u0000\u0000\u0000\u053e\u053f\u0005\u0013\u0000\u0000\u053f\u0540\u0005"+ + "\u01ba\u0000\u0000\u0540\u0541\u0003\u0202\u0101\u0000\u0541\u0542\u0005"+ + "\u0207\u0000\u0000\u0542\u0543\u0005\u02ff\u0000\u0000\u0543\u0544\u0003"+ + "\u01d4\u00ea\u0000\u0544\u0545\u0005\u0300\u0000\u0000\u0545\u0555\u0001"+ + "\u0000\u0000\u0000\u0546\u0547\u0005\u0013\u0000\u0000\u0547\u0548\u0005"+ + "\u01ba\u0000\u0000\u0548\u0549\u0003\u0202\u0101\u0000\u0549\u054a\u0005"+ + "\u0193\u0000\u0000\u054a\u054b\u0005\u0247\u0000\u0000\u054b\u054c\u0003"+ + "\u01fa\u00fd\u0000\u054c\u0555\u0001\u0000\u0000\u0000\u054d\u054e\u0005"+ + "\u0013\u0000\u0000\u054e\u054f\u0005\u01ba\u0000\u0000\u054f\u0550\u0003"+ + "\u0202\u0101\u0000\u0550\u0551\u0005\u01d4\u0000\u0000\u0551\u0552\u0005"+ + "\u0247\u0000\u0000\u0552\u0553\u0003\u01cc\u00e6\u0000\u0553\u0555\u0001"+ + "\u0000\u0000\u0000\u0554\u0520\u0001\u0000\u0000\u0000\u0554\u052a\u0001"+ + "\u0000\u0000\u0000\u0554\u0534\u0001\u0000\u0000\u0000\u0554\u053e\u0001"+ + "\u0000\u0000\u0000\u0554\u0546\u0001\u0000\u0000\u0000\u0554\u054d\u0001"+ + "\u0000\u0000\u0000\u05555\u0001\u0000\u0000\u0000\u0556\u0570\u0005\u0290"+ + "\u0000\u0000\u0557\u0570\u0005\u0291\u0000\u0000\u0558\u0570\u0005\u007f"+ + "\u0000\u0000\u0559\u0570\u0005\u0168\u0000\u0000\u055a\u0570\u0005\u0292"+ + "\u0000\u0000\u055b\u0570\u0005\u0293\u0000\u0000\u055c\u0570\u0005\u0294"+ + "\u0000\u0000\u055d\u0570\u0005\u0295\u0000\u0000\u055e\u0570\u0005\u0296"+ + "\u0000\u0000\u055f\u0570\u0005\u0297\u0000\u0000\u0560\u0570\u0005\u0298"+ + "\u0000\u0000\u0561\u0570\u0005\u0299\u0000\u0000\u0562\u0570\u0005\u029a"+ + "\u0000\u0000\u0563\u0570\u0005\u029b\u0000\u0000\u0564\u0565\u0005k\u0000"+ + "\u0000\u0565\u0566\u0005\u0136\u0000\u0000\u0566\u0570\u0005\u011b\u0000"+ + "\u0000\u0567\u0569\u0005\u00c5\u0000\u0000\u0568\u0567\u0001\u0000\u0000"+ + "\u0000\u0568\u0569\u0001\u0000\u0000\u0000\u0569\u056a\u0001\u0000\u0000"+ + "\u0000\u056a\u056b\u0005\u01a1\u0000\u0000\u056b\u0570\u0005\u0309\u0000"+ + "\u0000\u056c\u056d\u0005\u0274\u0000\u0000\u056d\u056e\u0005\u0269\u0000"+ + "\u0000\u056e\u0570\u0005\u0309\u0000\u0000\u056f\u0556\u0001\u0000\u0000"+ + "\u0000\u056f\u0557\u0001\u0000\u0000\u0000\u056f\u0558\u0001\u0000\u0000"+ + "\u0000\u056f\u0559\u0001\u0000\u0000\u0000\u056f\u055a\u0001\u0000\u0000"+ + "\u0000\u056f\u055b\u0001\u0000\u0000\u0000\u056f\u055c\u0001\u0000\u0000"+ + "\u0000\u056f\u055d\u0001\u0000\u0000\u0000\u056f\u055e\u0001\u0000\u0000"+ + "\u0000\u056f\u055f\u0001\u0000\u0000\u0000\u056f\u0560\u0001\u0000\u0000"+ + "\u0000\u056f\u0561\u0001\u0000\u0000\u0000\u056f\u0562\u0001\u0000\u0000"+ + "\u0000\u056f\u0563\u0001\u0000\u0000\u0000\u056f\u0564\u0001\u0000\u0000"+ + "\u0000\u056f\u0568\u0001\u0000\u0000\u0000\u056f\u056c\u0001\u0000\u0000"+ + "\u0000\u05707\u0001\u0000\u0000\u0000\u0571\u0572\u0005\u0013\u0000\u0000"+ + "\u0572\u0573\u0005\u01e5\u0000\u0000\u0573\u0575\u0003\u01fa\u00fd\u0000"+ + "\u0574\u0576\u0005\u0287\u0000\u0000\u0575\u0574\u0001\u0000\u0000\u0000"+ + "\u0575\u0576\u0001\u0000\u0000\u0000\u0576\u0578\u0001\u0000\u0000\u0000"+ + "\u0577\u0579\u00036\u001b\u0000\u0578\u0577\u0001\u0000\u0000\u0000\u0579"+ + "\u057a\u0001\u0000\u0000\u0000\u057a\u0578\u0001\u0000\u0000\u0000\u057a"+ + "\u057b\u0001\u0000\u0000\u0000\u057b\u05c0\u0001\u0000\u0000\u0000\u057c"+ + "\u057d\u0005\u0013\u0000\u0000\u057d\u057e\u0005\u01e5\u0000\u0000\u057e"+ + "\u057f\u0003\u01cc\u00e6\u0000\u057f\u0580\u0005\u01d4\u0000\u0000\u0580"+ + "\u0581\u0005\u0247\u0000\u0000\u0581\u0582\u0003\u01cc\u00e6\u0000\u0582"+ + "\u05c0\u0001\u0000\u0000\u0000\u0583\u0584\u0005\u0013\u0000\u0000\u0584"+ + "\u0587\u0005\u01e5\u0000\u0000\u0585\u0588\u0003\u01fa\u00fd\u0000\u0586"+ + "\u0588\u0005\u0010\u0000\u0000\u0587\u0585\u0001\u0000\u0000\u0000\u0587"+ + "\u0586\u0001\u0000\u0000\u0000\u0588\u058c\u0001\u0000\u0000\u0000\u0589"+ + "\u058a\u0005\u0109\u0000\u0000\u058a\u058b\u0005\u0092\u0000\u0000\u058b"+ + "\u058d\u0003\u01cc\u00e6\u0000\u058c\u0589\u0001\u0000\u0000\u0000\u058c"+ + "\u058d\u0001\u0000\u0000\u0000\u058d\u058e\u0001\u0000\u0000\u0000\u058e"+ + "\u058f\u0005\u0207\u0000\u0000\u058f\u0590\u0003\u0202\u0101\u0000\u0590"+ + "\u0593\u0007\u0005\u0000\u0000\u0591\u0594\u0003\u01fe\u00ff\u0000\u0592"+ + "\u0594\u0005\u009b\u0000\u0000\u0593\u0591\u0001\u0000\u0000\u0000\u0593"+ + "\u0592\u0001\u0000\u0000\u0000\u0594\u05c0\u0001\u0000\u0000\u0000\u0595"+ + "\u0596\u0005\u0013\u0000\u0000\u0596\u0599\u0005\u01e5\u0000\u0000\u0597"+ + "\u059a\u0003\u01fa\u00fd\u0000\u0598\u059a\u0005\u0010\u0000\u0000\u0599"+ + "\u0597\u0001\u0000\u0000\u0000\u0599\u0598\u0001\u0000\u0000\u0000\u059a"+ + "\u059e\u0001\u0000\u0000\u0000\u059b\u059c\u0005\u0109\u0000\u0000\u059c"+ + "\u059d\u0005\u0092\u0000\u0000\u059d\u059f\u0003\u01cc\u00e6\u0000\u059e"+ + "\u059b\u0001\u0000\u0000\u0000\u059e\u059f\u0001\u0000\u0000\u0000\u059f"+ + "\u05a0\u0001\u0000\u0000\u0000\u05a0\u05a1\u0005\u0207\u0000\u0000\u05a1"+ + "\u05a2\u0003\u0202\u0101\u0000\u05a2\u05a3\u0005\u00ec\u0000\u0000\u05a3"+ + "\u05a4\u0005\u0085\u0000\u0000\u05a4\u05c0\u0001\u0000\u0000\u0000\u05a5"+ + "\u05a6\u0005\u0013\u0000\u0000\u05a6\u05a9\u0005\u01e5\u0000\u0000\u05a7"+ + "\u05aa\u0003\u01fa\u00fd\u0000\u05a8\u05aa\u0005\u0010\u0000\u0000\u05a9"+ + "\u05a7\u0001\u0000\u0000\u0000\u05a9\u05a8\u0001\u0000\u0000\u0000\u05aa"+ + "\u05ae\u0001\u0000\u0000\u0000\u05ab\u05ac\u0005\u0109\u0000\u0000\u05ac"+ + "\u05ad\u0005\u0092\u0000\u0000\u05ad\u05af\u0003\u01cc\u00e6\u0000\u05ae"+ + "\u05ab\u0001\u0000\u0000\u0000\u05ae\u05af\u0001\u0000\u0000\u0000\u05af"+ + "\u05b0\u0001\u0000\u0000\u0000\u05b0\u05b1\u0005\u01d8\u0000\u0000\u05b1"+ + "\u05c0\u0003\u0202\u0101\u0000\u05b2\u05b3\u0005\u0013\u0000\u0000\u05b3"+ + "\u05b6\u0005\u01e5\u0000\u0000\u05b4\u05b7\u0003\u01fa\u00fd\u0000\u05b5"+ + "\u05b7\u0005\u0010\u0000\u0000\u05b6\u05b4\u0001\u0000\u0000\u0000\u05b6"+ + "\u05b5\u0001\u0000\u0000\u0000\u05b7\u05bb\u0001\u0000\u0000\u0000\u05b8"+ + "\u05b9\u0005\u0109\u0000\u0000\u05b9\u05ba\u0005\u0092\u0000\u0000\u05ba"+ + "\u05bc\u0003\u01cc\u00e6\u0000\u05bb\u05b8\u0001\u0000\u0000\u0000\u05bb"+ + "\u05bc\u0001\u0000\u0000\u0000\u05bc\u05bd\u0001\u0000\u0000\u0000\u05bd"+ + "\u05be\u0005\u01d8\u0000\u0000\u05be\u05c0\u0005\u0010\u0000\u0000\u05bf"+ + "\u0571\u0001\u0000\u0000\u0000\u05bf\u057c\u0001\u0000\u0000\u0000\u05bf"+ + "\u0583\u0001\u0000\u0000\u0000\u05bf\u0595\u0001\u0000\u0000\u0000\u05bf"+ + "\u05a5\u0001\u0000\u0000\u0000\u05bf\u05b2\u0001\u0000\u0000\u0000\u05c0"+ + "9\u0001\u0000\u0000\u0000\u05c1\u05c2\u0005\u0013\u0000\u0000\u05c2\u05c3"+ + "\u0005\u01f0\u0000\u0000\u05c3\u05c4\u0003\u01cc\u00e6\u0000\u05c4\u05c5"+ + "\u0005\u0180\u0000\u0000\u05c5\u05c6\u0003\u0202\u0101\u0000\u05c6\u05c7"+ + "\u0005\u01d4\u0000\u0000\u05c7\u05c8\u0005\u0247\u0000\u0000\u05c8\u05c9"+ + "\u0003\u01cc\u00e6\u0000\u05c9;\u0001\u0000\u0000\u0000\u05ca\u05cb\u0005"+ + "\u0013\u0000\u0000\u05cb\u05cc\u0005\u01f3\u0000\u0000\u05cc\u05cd\u0003"+ + "\u0202\u0101\u0000\u05cd\u05ce\u0005\u01d4\u0000\u0000\u05ce\u05cf\u0005"+ + "\u0247\u0000\u0000\u05cf\u05d0\u0003\u0202\u0101\u0000\u05d0\u05dc\u0001"+ + "\u0000\u0000\u0000\u05d1\u05d2\u0005\u0013\u0000\u0000\u05d2\u05d3\u0005"+ + "\u01f3\u0000\u0000\u05d3\u05d4\u0003\u0202\u0101\u0000\u05d4\u05d5\u0005"+ + "\u0193\u0000\u0000\u05d5\u05d9\u0005\u0247\u0000\u0000\u05d6\u05da\u0003"+ + "\u0202\u0101\u0000\u05d7\u05da\u0005\u008d\u0000\u0000\u05d8\u05da\u0005"+ + "\u0206\u0000\u0000\u05d9\u05d6\u0001\u0000\u0000\u0000\u05d9\u05d7\u0001"+ + "\u0000\u0000\u0000\u05d9\u05d8\u0001\u0000\u0000\u0000\u05da\u05dc\u0001"; + private static final String _serializedATNSegment1 = + "\u0000\u0000\u0000\u05db\u05ca\u0001\u0000\u0000\u0000\u05db\u05d1\u0001"+ + "\u0000\u0000\u0000\u05dc=\u0001\u0000\u0000\u0000\u05dd\u05de\u0005\u0013"+ + "\u0000\u0000\u05de\u05e1\u0005\u0201\u0000\u0000\u05df\u05e0\u0005\u02b3"+ + "\u0000\u0000\u05e0\u05e2\u0005\u00d3\u0000\u0000\u05e1\u05df\u0001\u0000"+ + "\u0000\u0000\u05e1\u05e2\u0001\u0000\u0000\u0000\u05e2\u05e3\u0001\u0000"+ + "\u0000\u0000\u05e3\u05e4\u0003\u01cc\u00e6\u0000\u05e4?\u0001\u0000\u0000"+ + "\u0000\u05e5\u05e7\u0007\u0004\u0000\u0000\u05e6\u05e5\u0001\u0000\u0000"+ + "\u0000\u05e6\u05e7\u0001\u0000\u0000\u0000\u05e7\u05e8\u0001\u0000\u0000"+ + "\u0000\u05e8\u05ea\u0003\u0202\u0101\u0000\u05e9\u05eb\u0003\u01fe\u00ff"+ + "\u0000\u05ea\u05e9\u0001\u0000\u0000\u0000\u05ea\u05eb\u0001\u0000\u0000"+ + "\u0000\u05eb\u05f6\u0001\u0000\u0000\u0000\u05ec\u05ee\u0005\u02f9\u0000"+ + "\u0000\u05ed\u05ef\u0007\u0004\u0000\u0000\u05ee\u05ed\u0001\u0000\u0000"+ + "\u0000\u05ee\u05ef\u0001\u0000\u0000\u0000\u05ef\u05f0\u0001\u0000\u0000"+ + "\u0000\u05f0\u05f2\u0003\u0202\u0101\u0000\u05f1\u05f3\u0003\u01fe\u00ff"+ + "\u0000\u05f2\u05f1\u0001\u0000\u0000\u0000\u05f2\u05f3\u0001\u0000\u0000"+ + "\u0000\u05f3\u05f5\u0001\u0000\u0000\u0000\u05f4\u05ec\u0001\u0000\u0000"+ + "\u0000\u05f5\u05f8\u0001\u0000\u0000\u0000\u05f6\u05f4\u0001\u0000\u0000"+ + "\u0000\u05f6\u05f7\u0001\u0000\u0000\u0000\u05f7A\u0001\u0000\u0000\u0000"+ + "\u05f8\u05f6\u0001\u0000\u0000\u0000\u05f9\u05fa\u0005\u0013\u0000\u0000"+ + "\u05fa\u05fb\u0005\u02bd\u0000\u0000\u05fb\u0607\u0003\u0202\u0101\u0000"+ + "\u05fc\u05fd\u0005\u02b8\u0000\u0000\u05fd\u0608\u0005\u0309\u0000\u0000"+ + "\u05fe\u05ff\u0005\u02b8\u0000\u0000\u05ff\u0601\u0005\u0309\u0000\u0000"+ + "\u0600\u05fe\u0001\u0000\u0000\u0000\u0600\u0601\u0001\u0000\u0000\u0000"+ + "\u0601\u0602\u0001\u0000\u0000\u0000\u0602\u0603\u0005\u0186\u0000\u0000"+ + "\u0603\u0604\u0005\u02ff\u0000\u0000\u0604\u0605\u0003@ \u0000\u0605\u0606"+ + "\u0005\u0300\u0000\u0000\u0606\u0608\u0001\u0000\u0000\u0000\u0607\u05fc"+ + "\u0001\u0000\u0000\u0000\u0607\u0600\u0001\u0000\u0000\u0000\u0608\u0618"+ + "\u0001\u0000\u0000\u0000\u0609\u060a\u0005\u0013\u0000\u0000\u060a\u060b"+ + "\u0005\u02bd\u0000\u0000\u060b\u060c\u0003\u0202\u0101\u0000\u060c\u060d"+ + "\u0005\u0193\u0000\u0000\u060d\u060e\u0005\u0247\u0000\u0000\u060e\u060f"+ + "\u0003\u01fa\u00fd\u0000\u060f\u0618\u0001\u0000\u0000\u0000\u0610\u0611"+ + "\u0005\u0013\u0000\u0000\u0611\u0612\u0005\u02bd\u0000\u0000\u0612\u0613"+ + "\u0003\u0202\u0101\u0000\u0613\u0614\u0005\u01d4\u0000\u0000\u0614\u0615"+ + "\u0005\u0247\u0000\u0000\u0615\u0616\u0003\u01cc\u00e6\u0000\u0616\u0618"+ + "\u0001\u0000\u0000\u0000\u0617\u05f9\u0001\u0000\u0000\u0000\u0617\u0609"+ + "\u0001\u0000\u0000\u0000\u0617\u0610\u0001\u0000\u0000\u0000\u0618C\u0001"+ + "\u0000\u0000\u0000\u0619\u061a\u0005\u0013\u0000\u0000\u061a\u061b\u0005"+ + "\u0224\u0000\u0000\u061b\u061c\u0003\u0202\u0101\u0000\u061c\u061d\u0005"+ + "\u0193\u0000\u0000\u061d\u0621\u0005\u0247\u0000\u0000\u061e\u0622\u0003"+ + "\u0202\u0101\u0000\u061f\u0622\u0005\u008d\u0000\u0000\u0620\u0622\u0005"+ + "\u0206\u0000\u0000\u0621\u061e\u0001\u0000\u0000\u0000\u0621\u061f\u0001"+ + "\u0000\u0000\u0000\u0621\u0620\u0001\u0000\u0000\u0000\u0622\u0632\u0001"+ + "\u0000\u0000\u0000\u0623\u0624\u0005\u0013\u0000\u0000\u0624\u0625\u0005"+ + "\u0224\u0000\u0000\u0625\u0626\u0003\u0202\u0101\u0000\u0626\u0627\u0005"+ + "\u01d4\u0000\u0000\u0627\u0628\u0005\u0247\u0000\u0000\u0628\u0629\u0003"+ + "\u0202\u0101\u0000\u0629\u0632\u0001\u0000\u0000\u0000\u062a\u062b\u0005"+ + "\u0013\u0000\u0000\u062b\u062c\u0005\u0224\u0000\u0000\u062c\u062d\u0003"+ + "\u0202\u0101\u0000\u062d\u062e\u0005\u0207\u0000\u0000\u062e\u062f\u0005"+ + "\u01f3\u0000\u0000\u062f\u0630\u0003\u0202\u0101\u0000\u0630\u0632\u0001"+ + "\u0000\u0000\u0000\u0631\u0619\u0001\u0000\u0000\u0000\u0631\u0623\u0001"+ + "\u0000\u0000\u0000\u0631\u062a\u0001\u0000\u0000\u0000\u0632E\u0001\u0000"+ + "\u0000\u0000\u0633\u0634\u0005\u0013\u0000\u0000\u0634\u0635\u0005\u0230"+ + "\u0000\u0000\u0635\u0636\u0003\u0202\u0101\u0000\u0636\u0637\u0005k\u0000"+ + "\u0000\u0637\u0638\u0003\u01fe\u00ff\u0000\u0638\u0673\u0001\u0000\u0000"+ + "\u0000\u0639\u063a\u0005\u0013\u0000\u0000\u063a\u063b\u0005\u0230\u0000"+ + "\u0000\u063b\u063c\u0003\u0202\u0101\u0000\u063c\u063d\u0005\u0207\u0000"+ + "\u0000\u063d\u063e\u0005\u01ba\u0000\u0000\u063e\u0644\u0003\u01ce\u00e7"+ + "\u0000\u063f\u0640\u0005\u0287\u0000\u0000\u0640\u0641\u0005\u02ff\u0000"+ + "\u0000\u0641\u0642\u0003\u01d4\u00ea\u0000\u0642\u0643\u0005\u0300\u0000"+ + "\u0000\u0643\u0645\u0001\u0000\u0000\u0000\u0644\u063f\u0001\u0000\u0000"+ + "\u0000\u0644\u0645\u0001\u0000\u0000\u0000\u0645\u0673\u0001\u0000\u0000"+ + "\u0000\u0646\u0647\u0005\u0013\u0000\u0000\u0647\u0648\u0005\u0230\u0000"+ + "\u0000\u0648\u0649\u0003\u0202\u0101\u0000\u0649\u064a\u0005\u01c7\u0000"+ + "\u0000\u064a\u0650\u0005\u01ba\u0000\u0000\u064b\u064c\u0005\u0287\u0000"+ + "\u0000\u064c\u064d\u0005\u02ff\u0000\u0000\u064d\u064e\u0003\u01d4\u00ea"+ + "\u0000\u064e\u064f\u0005\u0300\u0000\u0000\u064f\u0651\u0001\u0000\u0000"+ + "\u0000\u0650\u064b\u0001\u0000\u0000\u0000\u0650\u0651\u0001\u0000\u0000"+ + "\u0000\u0651\u0673\u0001\u0000\u0000\u0000\u0652\u0653\u0005\u0013\u0000"+ + "\u0000\u0653\u0654\u0005\u0230\u0000\u0000\u0654\u0655\u0003\u0202\u0101"+ + "\u0000\u0655\u0656\u0005\u00c3\u0000\u0000\u0656\u0673\u0001\u0000\u0000"+ + "\u0000\u0657\u0658\u0005\u0013\u0000\u0000\u0658\u0659\u0005\u0230\u0000"+ + "\u0000\u0659\u065a\u0003\u0202\u0101\u0000\u065a\u065b\u0005\u00b3\u0000"+ + "\u0000\u065b\u0673\u0001\u0000\u0000\u0000\u065c\u065d\u0005\u0013\u0000"+ + "\u0000\u065d\u065e\u0005\u0230\u0000\u0000\u065e\u065f\u0003\u0202\u0101"+ + "\u0000\u065f\u0660\u0005\u0207\u0000\u0000\u0660\u0661\u0005\u02ff\u0000"+ + "\u0000\u0661\u0662\u0003\u01d4\u00ea\u0000\u0662\u0663\u0005\u0300\u0000"+ + "\u0000\u0663\u0673\u0001\u0000\u0000\u0000\u0664\u0665\u0005\u0013\u0000"+ + "\u0000\u0665\u0666\u0005\u0230\u0000\u0000\u0666\u0667\u0003\u0202\u0101"+ + "\u0000\u0667\u0668\u0005\u0193\u0000\u0000\u0668\u0669\u0005\u0247\u0000"+ + "\u0000\u0669\u066a\u0003\u01fa\u00fd\u0000\u066a\u0673\u0001\u0000\u0000"+ + "\u0000\u066b\u066c\u0005\u0013\u0000\u0000\u066c\u066d\u0005\u0230\u0000"+ + "\u0000\u066d\u066e\u0003\u0202\u0101\u0000\u066e\u066f\u0005\u01d4\u0000"+ + "\u0000\u066f\u0670\u0005\u0247\u0000\u0000\u0670\u0671\u0003\u0202\u0101"+ + "\u0000\u0671\u0673\u0001\u0000\u0000\u0000\u0672\u0633\u0001\u0000\u0000"+ + "\u0000\u0672\u0639\u0001\u0000\u0000\u0000\u0672\u0646\u0001\u0000\u0000"+ + "\u0000\u0672\u0652\u0001\u0000\u0000\u0000\u0672\u0657\u0001\u0000\u0000"+ + "\u0000\u0672\u065c\u0001\u0000\u0000\u0000\u0672\u0664\u0001\u0000\u0000"+ + "\u0000\u0672\u066b\u0001\u0000\u0000\u0000\u0673G\u0001\u0000\u0000\u0000"+ + "\u0674\u0675\u0005\u0013\u0000\u0000\u0675\u0676\u0005\u0235\u0000\u0000"+ + "\u0676\u0677\u0005\u0207\u0000\u0000\u0677\u0678\u0005\u030b\u0000\u0000"+ + "\u0678\u0679\u0007\u0005\u0000\u0000\u0679\u0683\u0003\u01fe\u00ff\u0000"+ + "\u067a\u067b\u0005\u0013\u0000\u0000\u067b\u067c\u0005\u0235\u0000\u0000"+ + "\u067c\u067d\u0005\u01d8\u0000\u0000\u067d\u0683\u0005\u030b\u0000\u0000"+ + "\u067e\u067f\u0005\u0013\u0000\u0000\u067f\u0680\u0005\u0235\u0000\u0000"+ + "\u0680\u0681\u0005\u01d8\u0000\u0000\u0681\u0683\u0005\u0010\u0000\u0000"+ + "\u0682\u0674\u0001\u0000\u0000\u0000\u0682\u067a\u0001\u0000\u0000\u0000"+ + "\u0682\u067e\u0001\u0000\u0000\u0000\u0683I\u0001\u0000\u0000\u0000\u0684"+ + "\u0685\u0003\u0206\u0103\u0000\u0685K\u0001\u0000\u0000\u0000\u0686\u0687"+ + "\u0005\u0013\u0000\u0000\u0687\u0688\u0005\u023a\u0000\u0000\u0688\u0689"+ + "\u0003\u0202\u0101\u0000\u0689\u068a\u0005\u01d4\u0000\u0000\u068a\u068b"+ + "\u0005\u0247\u0000\u0000\u068b\u068c\u0003\u0202\u0101\u0000\u068c\u06a8"+ + "\u0001\u0000\u0000\u0000\u068d\u068e\u0005\u0013\u0000\u0000\u068e\u068f"+ + "\u0005\u023a\u0000\u0000\u068f\u0690\u0003\u0202\u0101\u0000\u0690\u0691"+ + "\u0005\u0193\u0000\u0000\u0691\u0695\u0005\u0247\u0000\u0000\u0692\u0696"+ + "\u0003\u0202\u0101\u0000\u0693\u0696\u0005\u008d\u0000\u0000\u0694\u0696"+ + "\u0005\u0206\u0000\u0000\u0695\u0692\u0001\u0000\u0000\u0000\u0695\u0693"+ + "\u0001\u0000\u0000\u0000\u0695\u0694\u0001\u0000\u0000\u0000\u0696\u06a8"+ + "\u0001\u0000\u0000\u0000\u0697\u0698\u0005\u0013\u0000\u0000\u0698\u0699"+ + "\u0005\u023a\u0000\u0000\u0699\u069a\u0003\u0202\u0101\u0000\u069a\u069b"+ + "\u0005\u0207\u0000\u0000\u069b\u069c\u0005\u02ff\u0000\u0000\u069c\u069d"+ + "\u0003\u01d4\u00ea\u0000\u069d\u069e\u0005\u0300\u0000\u0000\u069e\u06a8"+ + "\u0001\u0000\u0000\u0000\u069f\u06a0\u0005\u0013\u0000\u0000\u06a0\u06a1"+ + "\u0005\u023a\u0000\u0000\u06a1\u06a2\u0003\u0202\u0101\u0000\u06a2\u06a3"+ + "\u0005\u01d8\u0000\u0000\u06a3\u06a4\u0005\u02ff\u0000\u0000\u06a4\u06a5"+ + "\u0003\u01d0\u00e8\u0000\u06a5\u06a6\u0005\u0300\u0000\u0000\u06a6\u06a8"+ + "\u0001\u0000\u0000\u0000\u06a7\u0686\u0001\u0000\u0000\u0000\u06a7\u068d"+ + "\u0001\u0000\u0000\u0000\u06a7\u0697\u0001\u0000\u0000\u0000\u06a7\u069f"+ + "\u0001\u0000\u0000\u0000\u06a8M\u0001\u0000\u0000\u0000\u06a9\u06aa\u0005"+ + "\u0013\u0000\u0000\u06aa\u06ab\u0005\u02f0\u0000\u0000\u06ab\u06ac\u0005"+ + "\u01fa\u0000\u0000\u06ac\u06ad\u0005h\u0000\u0000\u06ad\u06ae\u0003\u0202"+ + "\u0101\u0000\u06ae\u06af\u0005\u000b\u0000\u0000\u06af\u06b0\u0005\u0145"+ + "\u0000\u0000\u06b0\u06b1\u0005\u00e3\u0000\u0000\u06b1\u06b2\u0003\u01d0"+ + "\u00e8\u0000\u06b2\u06b3\u0005\u0287\u0000\u0000\u06b3\u06b4\u0003\u01d0"+ + "\u00e8\u0000\u06b4\u0705\u0001\u0000\u0000\u0000\u06b5\u06b6\u0005\u0013"+ + "\u0000\u0000\u06b6\u06b7\u0005\u02f0\u0000\u0000\u06b7\u06b8\u0005\u01fa"+ + "\u0000\u0000\u06b8\u06b9\u0005h\u0000\u0000\u06b9\u06ba\u0003\u0202\u0101"+ + "\u0000\u06ba\u06bb\u0005\u0013\u0000\u0000\u06bb\u06bc\u0005\u0145\u0000"+ + "\u0000\u06bc\u06bd\u0005\u00e3\u0000\u0000\u06bd\u06be\u0003\u01d0\u00e8"+ + "\u0000\u06be\u06bf\u0005\u0287\u0000\u0000\u06bf\u06c0\u0003\u01d0\u00e8"+ + "\u0000\u06c0\u0705\u0001\u0000\u0000\u0000\u06c1\u06c2\u0005\u0013\u0000"+ + "\u0000\u06c2\u06c3\u0005\u02f0\u0000\u0000\u06c3\u06c4\u0005\u01fa\u0000"+ + "\u0000\u06c4\u06c5\u0005h\u0000\u0000\u06c5\u06c6\u0003\u0202\u0101\u0000"+ + "\u06c6\u06c7\u0005\u0013\u0000\u0000\u06c7\u06c8\u0005\u0145\u0000\u0000"+ + "\u06c8\u06c9\u0005\u01d6\u0000\u0000\u06c9\u06ca\u0003\u0202\u0101\u0000"+ + "\u06ca\u06cb\u0005\u0287\u0000\u0000\u06cb\u06cc\u0003\u0202\u0101\u0000"+ + "\u06cc\u0705\u0001\u0000\u0000\u0000\u06cd\u06ce\u0005\u0013\u0000\u0000"+ + "\u06ce\u06cf\u0005\u02f0\u0000\u0000\u06cf\u06d0\u0005\u01fa\u0000\u0000"+ + "\u06d0\u06d1\u0005h\u0000\u0000\u06d1\u06d2\u0003\u0202\u0101\u0000\u06d2"+ + "\u06d3\u0005\u0013\u0000\u0000\u06d3\u06d4\u0005\u0145\u0000\u0000\u06d4"+ + "\u06d5\u0005\u00e3\u0000\u0000\u06d5\u06d6\u0003\u01d0\u00e8\u0000\u06d6"+ + "\u06d7\u0005\u01d6\u0000\u0000\u06d7\u06d8\u0003\u0202\u0101\u0000\u06d8"+ + "\u06d9\u0005\u0287\u0000\u0000\u06d9\u06da\u0003\u0202\u0101\u0000\u06da"+ + "\u0705\u0001\u0000\u0000\u0000\u06db\u06dc\u0005\u0013\u0000\u0000\u06dc"+ + "\u06dd\u0005\u02f0\u0000\u0000\u06dd\u06de\u0005\u01fa\u0000\u0000\u06de"+ + "\u06df\u0005h\u0000\u0000\u06df\u06e0\u0003\u0202\u0101\u0000\u06e0\u06e1"+ + "\u0005\u00bc\u0000\u0000\u06e1\u06e4\u0005\u0145\u0000\u0000\u06e2\u06e3"+ + "\u0005\u02b3\u0000\u0000\u06e3\u06e5\u0005\u00d3\u0000\u0000\u06e4\u06e2"+ + "\u0001\u0000\u0000\u0000\u06e4\u06e5\u0001\u0000\u0000\u0000\u06e5\u06e6"+ + "\u0001\u0000\u0000\u0000\u06e6\u06e7\u0005\u00e3\u0000\u0000\u06e7\u06e8"+ + "\u0003\u01d0\u00e8\u0000\u06e8\u0705\u0001\u0000\u0000\u0000\u06e9\u06ea"+ + "\u0005\u0013\u0000\u0000\u06ea\u06eb\u0005\u02f0\u0000\u0000\u06eb\u06ec"+ + "\u0005\u01fa\u0000\u0000\u06ec\u06ed\u0005h\u0000\u0000\u06ed\u06ee\u0003"+ + "\u0202\u0101\u0000\u06ee\u06ef\u0005\u01d4\u0000\u0000\u06ef\u06f0\u0005"+ + "\u0247\u0000\u0000\u06f0\u06f1\u0003\u0202\u0101\u0000\u06f1\u0705\u0001"+ + "\u0000\u0000\u0000\u06f2\u06f3\u0005\u0013\u0000\u0000\u06f3\u06f4\u0005"+ + "\u02f0\u0000\u0000\u06f4\u06f5\u0005\u01fa\u0000\u0000\u06f5\u06f6\u0005"+ + "h\u0000\u0000\u06f6\u06f7\u0003\u0202\u0101\u0000\u06f7\u06f8\u0005\u0193"+ + "\u0000\u0000\u06f8\u06f9\u0005\u0247\u0000\u0000\u06f9\u06fa\u0003\u01fa"+ + "\u00fd\u0000\u06fa\u0705\u0001\u0000\u0000\u0000\u06fb\u06fc\u0005\u0013"+ + "\u0000\u0000\u06fc\u06fd\u0005\u02f0\u0000\u0000\u06fd\u06fe\u0005\u01fa"+ + "\u0000\u0000\u06fe\u06ff\u0005h\u0000\u0000\u06ff\u0700\u0003\u0202\u0101"+ + "\u0000\u0700\u0701\u0005\u0207\u0000\u0000\u0701\u0702\u0005\u01f3\u0000"+ + "\u0000\u0702\u0703\u0003\u0202\u0101\u0000\u0703\u0705\u0001\u0000\u0000"+ + "\u0000\u0704\u06a9\u0001\u0000\u0000\u0000\u0704\u06b5\u0001\u0000\u0000"+ + "\u0000\u0704\u06c1\u0001\u0000\u0000\u0000\u0704\u06cd\u0001\u0000\u0000"+ + "\u0000\u0704\u06db\u0001\u0000\u0000\u0000\u0704\u06e9\u0001\u0000\u0000"+ + "\u0000\u0704\u06f2\u0001\u0000\u0000\u0000\u0704\u06fb\u0001\u0000\u0000"+ + "\u0000\u0705O\u0001\u0000\u0000\u0000\u0706\u0707\u0003\u0206\u0103\u0000"+ + "\u0707Q\u0001\u0000\u0000\u0000\u0708\u0709\u0003\u0206\u0103\u0000\u0709"+ + "S\u0001\u0000\u0000\u0000\u070a\u070b\u0005\u0013\u0000\u0000\u070b\u070c"+ + "\u0005\u02f0\u0000\u0000\u070c\u070d\u0005\u01fa\u0000\u0000\u070d\u070e"+ + "\u0005\u023c\u0000\u0000\u070e\u070f\u0003\u0202\u0101\u0000\u070f\u0710"+ + "\u0005\u01d4\u0000\u0000\u0710\u0711\u0005\u0247\u0000\u0000\u0711\u0712"+ + "\u0003\u0202\u0101\u0000\u0712\u071d\u0001\u0000\u0000\u0000\u0713\u0714"+ + "\u0005\u0013\u0000\u0000\u0714\u0715\u0005\u02f0\u0000\u0000\u0715\u0716"+ + "\u0005\u01fa\u0000\u0000\u0716\u0717\u0005\u023c\u0000\u0000\u0717\u0718"+ + "\u0003\u0202\u0101\u0000\u0718\u0719\u0005\u0207\u0000\u0000\u0719\u071a"+ + "\u0005\u01f3\u0000\u0000\u071a\u071b\u0003\u0202\u0101\u0000\u071b\u071d"+ + "\u0001\u0000\u0000\u0000\u071c\u070a\u0001\u0000\u0000\u0000\u071c\u0713"+ + "\u0001\u0000\u0000\u0000\u071dU\u0001\u0000\u0000\u0000\u071e\u071f\u0005"+ + "\u0013\u0000\u0000\u071f\u0720\u0005\u0254\u0000\u0000\u0720\u0721\u0003"+ + "\u0202\u0101\u0000\u0721\u0722\u0005\u0180\u0000\u0000\u0722\u0723\u0003"+ + "\u0202\u0101\u0000\u0723\u0724\u0005\u01d4\u0000\u0000\u0724\u0725\u0005"+ + "\u0247\u0000\u0000\u0725\u0726\u0003\u0202\u0101\u0000\u0726\u0732\u0001"+ + "\u0000\u0000\u0000\u0727\u0728\u0005\u0013\u0000\u0000\u0728\u0729\u0005"+ + "\u0254\u0000\u0000\u0729\u072a\u0003\u0202\u0101\u0000\u072a\u072b\u0005"+ + "\u0180\u0000\u0000\u072b\u072c\u0003\u0202\u0101\u0000\u072c\u072d\u0005"+ + "\u00a7\u0000\u0000\u072d\u072e\u0005\u0180\u0000\u0000\u072e\u072f\u0005"+ + "\u00d7\u0000\u0000\u072f\u0730\u0003\u0202\u0101\u0000\u0730\u0732\u0001"+ + "\u0000\u0000\u0000\u0731\u071e\u0001\u0000\u0000\u0000\u0731\u0727\u0001"+ + "\u0000\u0000\u0000\u0732W\u0001\u0000\u0000\u0000\u0733\u0734\u0003\u0206"+ + "\u0103\u0000\u0734Y\u0001\u0000\u0000\u0000\u0735\u0736\u0003\u0206\u0103"+ + "\u0000\u0736[\u0001\u0000\u0000\u0000\u0737\u0738\u0005\u0013\u0000\u0000"+ + "\u0738\u0739\u0005\u026d\u0000\u0000\u0739\u073a\u0005\u0145\u0000\u0000"+ + "\u073a\u073b\u0005\u00e3\u0000\u0000\u073b\u073c\u0003\u01fa\u00fd\u0000"+ + "\u073c\u073d\u0005\u02bd\u0000\u0000\u073d\u073e\u0003\u0202\u0101\u0000"+ + "\u073e\u073f\u0005\u0186\u0000\u0000\u073f\u0740\u0005\u02ff\u0000\u0000"+ + "\u0740\u0741\u0003@ \u0000\u0741\u0742\u0005\u0300\u0000\u0000\u0742]"+ + "\u0001\u0000\u0000\u0000\u0743\u0744\u0003\u0206\u0103\u0000\u0744_\u0001"+ + "\u0000\u0000\u0000\u0745\u0747\u0005\u0016\u0000\u0000\u0746\u0748\u0005"+ + "\u027f\u0000\u0000\u0747\u0746\u0001\u0000\u0000\u0000\u0747\u0748\u0001"+ + "\u0000\u0000\u0000\u0748\u0749\u0001\u0000\u0000\u0000\u0749\u074e\u0003"+ + "\u01d6\u00eb\u0000\u074a\u074b\u0005\u02ff\u0000\u0000\u074b\u074c\u0003"+ + "\u01ce\u00e7\u0000\u074c\u074d\u0005\u0300\u0000\u0000\u074d\u074f\u0001"+ + "\u0000\u0000\u0000\u074e\u074a\u0001\u0000\u0000\u0000\u074e\u074f\u0001"+ + "\u0000\u0000\u0000\u074fa\u0001\u0000\u0000\u0000\u0750\u0751\u0003\u0206"+ + "\u0103\u0000\u0751c\u0001\u0000\u0000\u0000\u0752\u0753\u0003\u0206\u0103"+ + "\u0000\u0753e\u0001\u0000\u0000\u0000\u0754\u0755\u0003\u0206\u0103\u0000"+ + "\u0755g\u0001\u0000\u0000\u0000\u0756\u0757\u0003\u0206\u0103\u0000\u0757"+ + "i\u0001\u0000\u0000\u0000\u0758\u0759\u0003\u0206\u0103\u0000\u0759k\u0001"+ + "\u0000\u0000\u0000\u075a\u075b\u0003\u0206\u0103\u0000\u075bm\u0001\u0000"+ + "\u0000\u0000\u075c\u0784\u0003p8\u0000\u075d\u0784\u0003r9\u0000\u075e"+ + "\u0784\u0003t:\u0000\u075f\u0784\u0003z=\u0000\u0760\u0784\u0003|>\u0000"+ + "\u0761\u0784\u0003~?\u0000\u0762\u0784\u0003\u0082A\u0000\u0763\u0784"+ + "\u0003\u0086C\u0000\u0764\u0784\u0003\u008aE\u0000\u0765\u0784\u0003\u008c"+ + "F\u0000\u0766\u0784\u0003\u008eG\u0000\u0767\u0784\u0003\u0090H\u0000"+ + "\u0768\u0784\u0003\u0092I\u0000\u0769\u0784\u0003\u0094J\u0000\u076a\u0784"+ + "\u0003\u0096K\u0000\u076b\u0784\u0003\u0098L\u0000\u076c\u0784\u0003\u009c"+ + "N\u0000\u076d\u0784\u0003\u009eO\u0000\u076e\u0784\u0003\u00a0P\u0000"+ + "\u076f\u0784\u0003\u00a2Q\u0000\u0770\u0784\u0003\u00a6S\u0000\u0771\u0784"+ + "\u0003\u00a8T\u0000\u0772\u0784\u0003\u00aaU\u0000\u0773\u0784\u0003\u00ac"+ + "V\u0000\u0774\u0784\u0003\u00aeW\u0000\u0775\u0784\u0003\u00b0X\u0000"+ + "\u0776\u0784\u0003\u00b2Y\u0000\u0777\u0784\u0003\u00b4Z\u0000\u0778\u0784"+ + "\u0003\u00b6[\u0000\u0779\u0784\u0003\u00b8\\\u0000\u077a\u0784\u0003"+ + "\u00ba]\u0000\u077b\u0784\u0003\u00bc^\u0000\u077c\u0784\u0003\u00be_"+ + "\u0000\u077d\u0784\u0003\u00c0`\u0000\u077e\u0784\u0003\u00c2a\u0000\u077f"+ + "\u0784\u0003\u00c4b\u0000\u0780\u0784\u0003\u00c6c\u0000\u0781\u0784\u0003"+ + "\u00c8d\u0000\u0782\u0784\u0003\u00cae\u0000\u0783\u075c\u0001\u0000\u0000"+ + "\u0000\u0783\u075d\u0001\u0000\u0000\u0000\u0783\u075e\u0001\u0000\u0000"+ + "\u0000\u0783\u075f\u0001\u0000\u0000\u0000\u0783\u0760\u0001\u0000\u0000"+ + "\u0000\u0783\u0761\u0001\u0000\u0000\u0000\u0783\u0762\u0001\u0000\u0000"+ + "\u0000\u0783\u0763\u0001\u0000\u0000\u0000\u0783\u0764\u0001\u0000\u0000"+ + "\u0000\u0783\u0765\u0001\u0000\u0000\u0000\u0783\u0766\u0001\u0000\u0000"+ + "\u0000\u0783\u0767\u0001\u0000\u0000\u0000\u0783\u0768\u0001\u0000\u0000"+ + "\u0000\u0783\u0769\u0001\u0000\u0000\u0000\u0783\u076a\u0001\u0000\u0000"+ + "\u0000\u0783\u076b\u0001\u0000\u0000\u0000\u0783\u076c\u0001\u0000\u0000"+ + "\u0000\u0783\u076d\u0001\u0000\u0000\u0000\u0783\u076e\u0001\u0000\u0000"+ + "\u0000\u0783\u076f\u0001\u0000\u0000\u0000\u0783\u0770\u0001\u0000\u0000"+ + "\u0000\u0783\u0771\u0001\u0000\u0000\u0000\u0783\u0772\u0001\u0000\u0000"+ + "\u0000\u0783\u0773\u0001\u0000\u0000\u0000\u0783\u0774\u0001\u0000\u0000"+ + "\u0000\u0783\u0775\u0001\u0000\u0000\u0000\u0783\u0776\u0001\u0000\u0000"+ + "\u0000\u0783\u0777\u0001\u0000\u0000\u0000\u0783\u0778\u0001\u0000\u0000"+ + "\u0000\u0783\u0779\u0001\u0000\u0000\u0000\u0783\u077a\u0001\u0000\u0000"+ + "\u0000\u0783\u077b\u0001\u0000\u0000\u0000\u0783\u077c\u0001\u0000\u0000"+ + "\u0000\u0783\u077d\u0001\u0000\u0000\u0000\u0783\u077e\u0001\u0000\u0000"+ + "\u0000\u0783\u077f\u0001\u0000\u0000\u0000\u0783\u0780\u0001\u0000\u0000"+ + "\u0000\u0783\u0781\u0001\u0000\u0000\u0000\u0783\u0782\u0001\u0000\u0000"+ + "\u0000\u0784o\u0001\u0000\u0000\u0000\u0785\u0786\u0005~\u0000\u0000\u0786"+ + "\u0787\u0005\b\u0000\u0000\u0787\u0788\u0005\u0150\u0000\u0000\u0788\u0789"+ + "\u0003\u01cc\u00e6\u0000\u0789\u078a\u0005\u025c\u0000\u0000\u078a\u078b"+ + "\u0005\u010c\u0000\u0000\u078b\u078c\u0005\u00fc\u0000\u0000\u078c\u078d"+ + "\u0003\u01cc\u00e6\u0000\u078dq\u0001\u0000\u0000\u0000\u078e\u078f\u0005"+ + "~\u0000\u0000\u078f\u0790\u0005\u000e\u0000\u0000\u0790\u0791\u0003\u01cc"+ + "\u00e6\u0000\u0791\u0793\u0005\u02ff\u0000\u0000\u0792\u0794\u0007\u0006"+ + "\u0000\u0000\u0793\u0792\u0001\u0000\u0000\u0000\u0793\u0794\u0001\u0000"+ + "\u0000\u0000\u0794\u0796\u0001\u0000\u0000\u0000\u0795\u0797\u0003\u01cc"+ + "\u00e6\u0000\u0796\u0795\u0001\u0000\u0000\u0000\u0796\u0797\u0001\u0000"+ + "\u0000\u0000\u0797\u0798\u0001\u0000\u0000\u0000\u0798\u0799\u0003\u01da"+ + "\u00ed\u0000\u0799\u079a\u0005\u0300\u0000\u0000\u079a\u079b\u0005\u02ff"+ + "\u0000\u0000\u079b\u079c\u0005\u029c\u0000\u0000\u079c\u079d\u0005\u0318"+ + "\u0000\u0000\u079d\u079e\u0003\u0202\u0101\u0000\u079e\u079f\u0005\u02f9"+ + "\u0000\u0000\u079f\u07a0\u0005\u029d\u0000\u0000\u07a0\u07a1\u0005\u0318"+ + "\u0000\u0000\u07a1\u07a6\u0003\u0202\u0101\u0000\u07a2\u07a3\u0005\u02f9"+ + "\u0000\u0000\u07a3\u07a4\u0005\u029e\u0000\u0000\u07a4\u07a5\u0005\u0318"+ + "\u0000\u0000\u07a5\u07a7\u0005\u0306\u0000\u0000\u07a6\u07a2\u0001\u0000"+ + "\u0000\u0000\u07a6\u07a7\u0001\u0000\u0000\u0000\u07a7\u07ac\u0001\u0000"+ + "\u0000\u0000\u07a8\u07a9\u0005\u02f9\u0000\u0000\u07a9\u07aa\u0005\u029f"+ + "\u0000\u0000\u07aa\u07ab\u0005\u0318\u0000\u0000\u07ab\u07ad\u0003\u0202"+ + "\u0101\u0000\u07ac\u07a8\u0001\u0000\u0000\u0000\u07ac\u07ad\u0001\u0000"+ + "\u0000\u0000\u07ad\u07b0\u0001\u0000\u0000\u0000\u07ae\u07af\u0005\u02f9"+ + "\u0000\u0000\u07af\u07b1\u0005\u02a0\u0000\u0000\u07b0\u07ae\u0001\u0000"+ + "\u0000\u0000\u07b0\u07b1\u0001\u0000\u0000\u0000\u07b1\u07b6\u0001\u0000"+ + "\u0000\u0000\u07b2\u07b3\u0005\u02f9\u0000\u0000\u07b3\u07b4\u0005\u02a1"+ + "\u0000\u0000\u07b4\u07b5\u0005\u0318\u0000\u0000\u07b5\u07b7\u0003\u0202"+ + "\u0101\u0000\u07b6\u07b2\u0001\u0000\u0000\u0000\u07b6\u07b7\u0001\u0000"+ + "\u0000\u0000\u07b7\u07bc\u0001\u0000\u0000\u0000\u07b8\u07b9\u0005\u02f9"+ + "\u0000\u0000\u07b9\u07ba\u0005\u02a2\u0000\u0000\u07ba\u07bb\u0005\u0318"+ + "\u0000\u0000\u07bb\u07bd\u0003\u0202\u0101\u0000\u07bc\u07b8\u0001\u0000"+ + "\u0000\u0000\u07bc\u07bd\u0001\u0000\u0000\u0000\u07bd\u07c2\u0001\u0000"+ + "\u0000\u0000\u07be\u07bf\u0005\u02f9\u0000\u0000\u07bf\u07c0\u0005\u02a3"+ + "\u0000\u0000\u07c0\u07c1\u0005\u0318\u0000\u0000\u07c1\u07c3\u0003\u0202"+ + "\u0101\u0000\u07c2\u07be\u0001\u0000\u0000\u0000\u07c2\u07c3\u0001\u0000"+ + "\u0000\u0000\u07c3\u07c8\u0001\u0000\u0000\u0000\u07c4\u07c5\u0005\u02f9"+ + "\u0000\u0000\u07c5\u07c6\u0005\u02a4\u0000\u0000\u07c6\u07c7\u0005\u0318"+ + "\u0000\u0000\u07c7\u07c9\u0003\u01b0\u00d8\u0000\u07c8\u07c4\u0001\u0000"+ + "\u0000\u0000\u07c8\u07c9\u0001\u0000\u0000\u0000\u07c9\u07ce\u0001\u0000"+ + "\u0000\u0000\u07ca\u07cb\u0005\u02f9\u0000\u0000\u07cb\u07cc\u0005\u02a5"+ + "\u0000\u0000\u07cc\u07cd\u0005\u0318\u0000\u0000\u07cd\u07cf\u0003\u0202"+ + "\u0101\u0000\u07ce\u07ca\u0001\u0000\u0000\u0000\u07ce\u07cf\u0001\u0000"+ + "\u0000\u0000\u07cf\u07d4\u0001\u0000\u0000\u0000\u07d0\u07d1\u0005\u02f9"+ + "\u0000\u0000\u07d1\u07d2\u0005\u02a6\u0000\u0000\u07d2\u07d3\u0005\u0318"+ + "\u0000\u0000\u07d3\u07d5\u0003\u0202\u0101\u0000\u07d4\u07d0\u0001\u0000"+ + "\u0000\u0000\u07d4\u07d5\u0001\u0000\u0000\u0000\u07d5\u07da\u0001\u0000"+ + "\u0000\u0000\u07d6\u07d7\u0005\u02f9\u0000\u0000\u07d7\u07d8\u0005\u02a7"+ + "\u0000\u0000\u07d8\u07d9\u0005\u0318\u0000\u0000\u07d9\u07db\u0003\u0202"+ + "\u0101\u0000\u07da\u07d6\u0001\u0000\u0000\u0000\u07da\u07db\u0001\u0000"+ + "\u0000\u0000\u07db\u07e0\u0001\u0000\u0000\u0000\u07dc\u07dd\u0005\u02f9"+ + "\u0000\u0000\u07dd\u07de\u0005\u02a8\u0000\u0000\u07de\u07df\u0005\u0318"+ + "\u0000\u0000\u07df\u07e1\u0005\u0306\u0000\u0000\u07e0\u07dc\u0001\u0000"+ + "\u0000\u0000\u07e0\u07e1\u0001\u0000\u0000\u0000\u07e1\u07e6\u0001\u0000"+ + "\u0000\u0000\u07e2\u07e3\u0005\u02f9\u0000\u0000\u07e3\u07e4\u0005\u02a9"+ + "\u0000\u0000\u07e4\u07e5\u0005\u0318\u0000\u0000\u07e5\u07e7\u0003\u0202"+ + "\u0101\u0000\u07e6\u07e2\u0001\u0000\u0000\u0000\u07e6\u07e7\u0001\u0000"+ + "\u0000\u0000\u07e7\u07ea\u0001\u0000\u0000\u0000\u07e8\u07e9\u0005\u02f9"+ + "\u0000\u0000\u07e9\u07eb\u0005\u02aa\u0000\u0000\u07ea\u07e8\u0001\u0000"+ + "\u0000\u0000\u07ea\u07eb\u0001\u0000\u0000\u0000\u07eb\u07f0\u0001\u0000"+ + "\u0000\u0000\u07ec\u07ed\u0005\u02f9\u0000\u0000\u07ed\u07ee\u0005\u02ab"+ + "\u0000\u0000\u07ee\u07ef\u0005\u0318\u0000\u0000\u07ef\u07f1\u0003\u0202"+ + "\u0101\u0000\u07f0\u07ec\u0001\u0000\u0000\u0000\u07f0\u07f1\u0001\u0000"+ + "\u0000\u0000\u07f1\u07f6\u0001\u0000\u0000\u0000\u07f2\u07f3\u0005\u02f9"+ + "\u0000\u0000\u07f3\u07f4\u0005\u02ac\u0000\u0000\u07f4\u07f5\u0005\u0318"+ + "\u0000\u0000\u07f5\u07f7\u0003\u0202\u0101\u0000\u07f6\u07f2\u0001\u0000"+ + "\u0000\u0000\u07f6\u07f7\u0001\u0000\u0000\u0000\u07f7\u07fc\u0001\u0000"+ + "\u0000\u0000\u07f8\u07f9\u0005\u02f9\u0000\u0000\u07f9\u07fa\u0005\u02ad"+ + "\u0000\u0000\u07fa\u07fb\u0005\u0318\u0000\u0000\u07fb\u07fd\u0007\u0007"+ + "\u0000\u0000\u07fc\u07f8\u0001\u0000\u0000\u0000\u07fc\u07fd\u0001\u0000"+ + "\u0000\u0000\u07fd\u07fe\u0001\u0000\u0000\u0000\u07fe\u07ff\u0005\u0300"+ + "\u0000\u0000\u07ff\u08a9\u0001\u0000\u0000\u0000\u0800\u0801\u0005~\u0000"+ + "\u0000\u0801\u0802\u0005\u000e\u0000\u0000\u0802\u0803\u0003\u01cc\u00e6"+ + "\u0000\u0803\u080b\u0005\u02ff\u0000\u0000\u0804\u0806\u0007\u0006\u0000"+ + "\u0000\u0805\u0804\u0001\u0000\u0000\u0000\u0805\u0806\u0001\u0000\u0000"+ + "\u0000\u0806\u0808\u0001\u0000\u0000\u0000\u0807\u0809\u0003\u01cc\u00e6"+ + "\u0000\u0808\u0807\u0001\u0000\u0000\u0000\u0808\u0809\u0001\u0000\u0000"+ + "\u0000\u0809\u080a\u0001\u0000\u0000\u0000\u080a\u080c\u0003\u01da\u00ed"+ + "\u0000\u080b\u0805\u0001\u0000\u0000\u0000\u080b\u080c\u0001\u0000\u0000"+ + "\u0000\u080c\u080d\u0001\u0000\u0000\u0000\u080d\u080e\u0005\u0188\u0000"+ + "\u0000\u080e\u0810\u00056\u0000\u0000\u080f\u0811\u0007\u0006\u0000\u0000"+ + "\u0810\u080f\u0001\u0000\u0000\u0000\u0810\u0811\u0001\u0000\u0000\u0000"+ + "\u0811\u0813\u0001\u0000\u0000\u0000\u0812\u0814\u0003\u01cc\u00e6\u0000"+ + "\u0813\u0812\u0001\u0000\u0000\u0000\u0813\u0814\u0001\u0000\u0000\u0000"+ + "\u0814\u0815\u0001\u0000\u0000\u0000\u0815\u0816\u0003\u01da\u00ed\u0000"+ + "\u0816\u0817\u0005\u0300\u0000\u0000\u0817\u0818\u0005\u02ff\u0000\u0000"+ + "\u0818\u0819\u0005\u029c\u0000\u0000\u0819\u081a\u0005\u0318\u0000\u0000"+ + "\u081a\u081b\u0003\u0202\u0101\u0000\u081b\u081c\u0005\u02f9\u0000\u0000"+ + "\u081c\u081d\u0005\u029d\u0000\u0000\u081d\u081e\u0005\u0318\u0000\u0000"+ + "\u081e\u0823\u0003\u0202\u0101\u0000\u081f\u0820\u0005\u02f9\u0000\u0000"+ + "\u0820\u0821\u0005\u029e\u0000\u0000\u0821\u0822\u0005\u0318\u0000\u0000"+ + "\u0822\u0824\u0005\u0306\u0000\u0000\u0823\u081f\u0001\u0000\u0000\u0000"+ + "\u0823\u0824\u0001\u0000\u0000\u0000\u0824\u0829\u0001\u0000\u0000\u0000"+ + "\u0825\u0826\u0005\u02f9\u0000\u0000\u0826\u0827\u0005\u029f\u0000\u0000"+ + "\u0827\u0828\u0005\u0318\u0000\u0000\u0828\u082a\u0003\u0202\u0101\u0000"+ + "\u0829\u0825\u0001\u0000\u0000\u0000\u0829\u082a\u0001\u0000\u0000\u0000"+ + "\u082a\u082d\u0001\u0000\u0000\u0000\u082b\u082c\u0005\u02f9\u0000\u0000"+ + "\u082c\u082e\u0005\u02a0\u0000\u0000\u082d\u082b\u0001\u0000\u0000\u0000"+ + "\u082d\u082e\u0001\u0000\u0000\u0000\u082e\u0833\u0001\u0000\u0000\u0000"+ + "\u082f\u0830\u0005\u02f9\u0000\u0000\u0830\u0831\u0005\u02a4\u0000\u0000"+ + "\u0831\u0832\u0005\u0318\u0000\u0000\u0832\u0834\u0003\u01b0\u00d8\u0000"+ + "\u0833\u082f\u0001\u0000\u0000\u0000\u0833\u0834\u0001\u0000\u0000\u0000"+ + "\u0834\u0839\u0001\u0000\u0000\u0000\u0835\u0836\u0005\u02f9\u0000\u0000"+ + "\u0836\u0837\u0005\u02ad\u0000\u0000\u0837\u0838\u0005\u0318\u0000\u0000"+ + "\u0838\u083a\u0007\u0007\u0000\u0000\u0839\u0835\u0001\u0000\u0000\u0000"+ + "\u0839\u083a\u0001\u0000\u0000\u0000\u083a\u083d\u0001\u0000\u0000\u0000"+ + "\u083b\u083c\u0005\u02f9\u0000\u0000\u083c\u083e\u0005\u02ae\u0000\u0000"+ + "\u083d\u083b\u0001\u0000\u0000\u0000\u083d\u083e\u0001\u0000\u0000\u0000"+ + "\u083e\u083f\u0001\u0000\u0000\u0000\u083f\u0840\u0005\u0300\u0000\u0000"+ + "\u0840\u08a9\u0001\u0000\u0000\u0000\u0841\u0842\u0005~\u0000\u0000\u0842"+ + "\u0843\u0005\u000e\u0000\u0000\u0843\u0844\u0003\u01cc\u00e6\u0000\u0844"+ + "\u0845\u0005\u02ff\u0000\u0000\u0845\u0846\u0005\u02b2\u0000\u0000\u0846"+ + "\u0847\u0005\u0318\u0000\u0000\u0847\u0848\u0003\u01d8\u00ec\u0000\u0848"+ + "\u0849\u0005\u02f9\u0000\u0000\u0849\u084a\u0005\u029c\u0000\u0000\u084a"+ + "\u084b\u0005\u0318\u0000\u0000\u084b\u084c\u0003\u0202\u0101\u0000\u084c"+ + "\u084d\u0005\u02f9\u0000\u0000\u084d\u084e\u0005\u029d\u0000\u0000\u084e"+ + "\u084f\u0005\u0318\u0000\u0000\u084f\u0854\u0003\u0202\u0101\u0000\u0850"+ + "\u0851\u0005\u02f9\u0000\u0000\u0851\u0852\u0005\u029e\u0000\u0000\u0852"+ + "\u0853\u0005\u0318\u0000\u0000\u0853\u0855\u0005\u0306\u0000\u0000\u0854"+ + "\u0850\u0001\u0000\u0000\u0000\u0854\u0855\u0001\u0000\u0000\u0000\u0855"+ + "\u085a\u0001\u0000\u0000\u0000\u0856\u0857\u0005\u02f9\u0000\u0000\u0857"+ + "\u0858\u0005\u029f\u0000\u0000\u0858\u0859\u0005\u0318\u0000\u0000\u0859"+ + "\u085b\u0003\u0202\u0101\u0000\u085a\u0856\u0001\u0000\u0000\u0000\u085a"+ + "\u085b\u0001\u0000\u0000\u0000\u085b\u085e\u0001\u0000\u0000\u0000\u085c"+ + "\u085d\u0005\u02f9\u0000\u0000\u085d\u085f\u0005\u02a0\u0000\u0000\u085e"+ + "\u085c\u0001\u0000\u0000\u0000\u085e\u085f\u0001\u0000\u0000\u0000\u085f"+ + "\u0864\u0001\u0000\u0000\u0000\u0860\u0861\u0005\u02f9\u0000\u0000\u0861"+ + "\u0862\u0005\u02a1\u0000\u0000\u0862\u0863\u0005\u0318\u0000\u0000\u0863"+ + "\u0865\u0003\u0202\u0101\u0000\u0864\u0860\u0001\u0000\u0000\u0000\u0864"+ + "\u0865\u0001\u0000\u0000\u0000\u0865\u086a\u0001\u0000\u0000\u0000\u0866"+ + "\u0867\u0005\u02f9\u0000\u0000\u0867\u0868\u0005\u02a2\u0000\u0000\u0868"+ + "\u0869\u0005\u0318\u0000\u0000\u0869\u086b\u0003\u0202\u0101\u0000\u086a"+ + "\u0866\u0001\u0000\u0000\u0000\u086a\u086b\u0001\u0000\u0000\u0000\u086b"+ + "\u0870\u0001\u0000\u0000\u0000\u086c\u086d\u0005\u02f9\u0000\u0000\u086d"+ + "\u086e\u0005\u02a3\u0000\u0000\u086e\u086f\u0005\u0318\u0000\u0000\u086f"+ + "\u0871\u0003\u0202\u0101\u0000\u0870\u086c\u0001\u0000\u0000\u0000\u0870"+ + "\u0871\u0001\u0000\u0000\u0000\u0871\u0876\u0001\u0000\u0000\u0000\u0872"+ + "\u0873\u0005\u02f9\u0000\u0000\u0873\u0874\u0005\u02a4\u0000\u0000\u0874"+ + "\u0875\u0005\u0318\u0000\u0000\u0875\u0877\u0003\u01b0\u00d8\u0000\u0876"+ + "\u0872\u0001\u0000\u0000\u0000\u0876\u0877\u0001\u0000\u0000\u0000\u0877"+ + "\u087c\u0001\u0000\u0000\u0000\u0878\u0879\u0005\u02f9\u0000\u0000\u0879"+ + "\u087a\u0005\u02a5\u0000\u0000\u087a\u087b\u0005\u0318\u0000\u0000\u087b"+ + "\u087d\u0003\u0202\u0101\u0000\u087c\u0878\u0001\u0000\u0000\u0000\u087c"+ + "\u087d\u0001\u0000\u0000\u0000\u087d\u0882\u0001\u0000\u0000\u0000\u087e"+ + "\u087f\u0005\u02f9\u0000\u0000\u087f\u0880\u0005\u02a6\u0000\u0000\u0880"+ + "\u0881\u0005\u0318\u0000\u0000\u0881\u0883\u0003\u0202\u0101\u0000\u0882"+ + "\u087e\u0001\u0000\u0000\u0000\u0882\u0883\u0001\u0000\u0000\u0000\u0883"+ + "\u0888\u0001\u0000\u0000\u0000\u0884\u0885\u0005\u02f9\u0000\u0000\u0885"+ + "\u0886\u0005\u02a7\u0000\u0000\u0886\u0887\u0005\u0318\u0000\u0000\u0887"+ + "\u0889\u0003\u0202\u0101\u0000\u0888\u0884\u0001\u0000\u0000\u0000\u0888"+ + "\u0889\u0001\u0000\u0000\u0000\u0889\u088e\u0001\u0000\u0000\u0000\u088a"+ + "\u088b\u0005\u02f9\u0000\u0000\u088b\u088c\u0005\u02a8\u0000\u0000\u088c"+ + "\u088d\u0005\u0318\u0000\u0000\u088d\u088f\u0005\u0306\u0000\u0000\u088e"+ + "\u088a\u0001\u0000\u0000\u0000\u088e\u088f\u0001\u0000\u0000\u0000\u088f"+ + "\u0894\u0001\u0000\u0000\u0000\u0890\u0891\u0005\u02f9\u0000\u0000\u0891"+ + "\u0892\u0005\u02a9\u0000\u0000\u0892\u0893\u0005\u0318\u0000\u0000\u0893"+ + "\u0895\u0003\u0202\u0101\u0000\u0894\u0890\u0001\u0000\u0000\u0000\u0894"+ + "\u0895\u0001\u0000\u0000\u0000\u0895\u0898\u0001\u0000\u0000\u0000\u0896"+ + "\u0897\u0005\u02f9\u0000\u0000\u0897\u0899\u0005\u02aa\u0000\u0000\u0898"+ + "\u0896\u0001\u0000\u0000\u0000\u0898\u0899\u0001\u0000\u0000\u0000\u0899"+ + "\u089e\u0001\u0000\u0000\u0000\u089a\u089b\u0005\u02f9\u0000\u0000\u089b"+ + "\u089c\u0005\u02ab\u0000\u0000\u089c\u089d\u0005\u0318\u0000\u0000\u089d"+ + "\u089f\u0003\u0202\u0101\u0000\u089e\u089a\u0001\u0000\u0000\u0000\u089e"+ + "\u089f\u0001\u0000\u0000\u0000\u089f\u08a4\u0001\u0000\u0000\u0000\u08a0"+ + "\u08a1\u0005\u02f9\u0000\u0000\u08a1\u08a2\u0005\u02ac\u0000\u0000\u08a2"+ + "\u08a3\u0005\u0318\u0000\u0000\u08a3\u08a5\u0003\u0202\u0101\u0000\u08a4"+ + "\u08a0\u0001\u0000\u0000\u0000\u08a4\u08a5\u0001\u0000\u0000\u0000\u08a5"+ + "\u08a6\u0001\u0000\u0000\u0000\u08a6\u08a7\u0005\u0300\u0000\u0000\u08a7"+ + "\u08a9\u0001\u0000\u0000\u0000\u08a8\u078e\u0001\u0000\u0000\u0000\u08a8"+ + "\u0800\u0001\u0000\u0000\u0000\u08a8\u0841\u0001\u0000\u0000\u0000\u08a9"+ + "s\u0001\u0000\u0000\u0000\u08aa\u08ab\u0005~\u0000\u0000\u08ab\u08ac\u0005"+ + "?\u0000\u0000\u08ac\u08ad\u0005\u02ff\u0000\u0000\u08ad\u08ae\u0003\u01d8"+ + "\u00ec\u0000\u08ae\u08af\u0005\u001b\u0000\u0000\u08af\u08b0\u0003\u01d8"+ + "\u00ec\u0000\u08b0\u08be\u0005\u0300\u0000\u0000\u08b1\u08b2\u0005\u0287"+ + "\u0000\u0000\u08b2\u08b3\u0005\u00ee\u0000\u0000\u08b3\u08b8\u0003\u0202"+ + "\u0101\u0000\u08b4\u08b5\u0005\u02ff\u0000\u0000\u08b5\u08b6\u0003\u01da"+ + "\u00ed\u0000\u08b6\u08b7\u0005\u0300\u0000\u0000\u08b7\u08b9\u0001\u0000"+ + "\u0000\u0000\u08b8\u08b4\u0001\u0000\u0000\u0000\u08b8\u08b9\u0001\u0000"+ + "\u0000\u0000\u08b9\u08bf\u0001\u0000\u0000\u0000\u08ba\u08bb\u0005\u0289"+ + "\u0000\u0000\u08bb\u08bf\u0005\u00ee\u0000\u0000\u08bc\u08bd\u0005\u0287"+ + "\u0000\u0000\u08bd\u08bf\u0005\u0113\u0000\u0000\u08be\u08b1\u0001\u0000"+ + "\u0000\u0000\u08be\u08ba\u0001\u0000\u0000\u0000\u08be\u08bc\u0001\u0000"+ + "\u0000\u0000\u08bf\u08c4\u0001\u0000\u0000\u0000\u08c0\u08c1\u0005\u001b"+ + "\u0000\u0000\u08c1\u08c5\u0005\u001f\u0000\u0000\u08c2\u08c3\u0005\u001b"+ + "\u0000\u0000\u08c3\u08c5\u0005\u0108\u0000\u0000\u08c4\u08c0\u0001\u0000"+ + "\u0000\u0000\u08c4\u08c2\u0001\u0000\u0000\u0000\u08c4\u08c5\u0001\u0000"+ + "\u0000\u0000\u08c5u\u0001\u0000\u0000\u0000\u08c6\u08c7\u0005\u02b4\u0000"+ + "\u0000\u08c7\u08c8\u0005\u0318\u0000\u0000\u08c8\u08d9\u0003\u01b0\u00d8"+ + "\u0000\u08c9\u08ca\u0005\u02b5\u0000\u0000\u08ca\u08cb\u0005\u0318\u0000"+ + "\u0000\u08cb\u08d9\u0003\u01b0\u00d8\u0000\u08cc\u08cd\u0005\u02b6\u0000"+ + "\u0000\u08cd\u08ce\u0005\u0318\u0000\u0000\u08ce\u08d9\u0003\u01b0\u00d8"+ + "\u0000\u08cf\u08d0\u0005\u02b7\u0000\u0000\u08d0\u08d1\u0005\u0318\u0000"+ + "\u0000\u08d1\u08d9\u0003\u01b0\u00d8\u0000\u08d2\u08d3\u0005\u02b8\u0000"+ + "\u0000\u08d3\u08d4\u0005\u0318\u0000\u0000\u08d4\u08d9\u0003\u01b0\u00d8"+ + "\u0000\u08d5\u08d6\u0005\u030a\u0000\u0000\u08d6\u08d7\u0005\u0318\u0000"+ + "\u0000\u08d7\u08d9\u0003\u01b0\u00d8\u0000\u08d8\u08c6\u0001\u0000\u0000"+ + "\u0000\u08d8\u08c9\u0001\u0000\u0000\u0000\u08d8\u08cc\u0001\u0000\u0000"+ + "\u0000\u08d8\u08cf\u0001\u0000\u0000\u0000\u08d8\u08d2\u0001\u0000\u0000"+ + "\u0000\u08d8\u08d5\u0001\u0000\u0000\u0000\u08d9w\u0001\u0000\u0000\u0000"+ + "\u08da\u08df\u0003v;\u0000\u08db\u08dc\u0005\u02f9\u0000\u0000\u08dc\u08de"+ + "\u0003v;\u0000\u08dd\u08db\u0001\u0000\u0000\u0000\u08de\u08e1\u0001\u0000"+ + "\u0000\u0000\u08df\u08dd\u0001\u0000\u0000\u0000\u08df\u08e0\u0001\u0000"+ + "\u0000\u0000\u08e0y\u0001\u0000\u0000\u0000\u08e1\u08df\u0001\u0000\u0000"+ + "\u0000\u08e2\u08e3\u0005~\u0000\u0000\u08e3\u08e7\u0005Y\u0000\u0000\u08e4"+ + "\u08e5\u0005\u02b3\u0000\u0000\u08e5\u08e6\u0005\u016d\u0000\u0000\u08e6"+ + "\u08e8\u0005\u00d3\u0000\u0000\u08e7\u08e4\u0001\u0000\u0000\u0000\u08e7"+ + "\u08e8\u0001\u0000\u0000\u0000\u08e8\u08e9\u0001\u0000\u0000\u0000\u08e9"+ + "\u08ea\u0003\u01cc\u00e6\u0000\u08ea\u08eb\u0005\u02ff\u0000\u0000\u08eb"+ + "\u08ec\u0003x<\u0000\u08ec\u08ed\u0005\u0300\u0000\u0000\u08ed\u08fa\u0001"+ + "\u0000\u0000\u0000\u08ee\u08ef\u0005~\u0000\u0000\u08ef\u08f3\u0005Y\u0000"+ + "\u0000\u08f0\u08f1\u0005\u02b3\u0000\u0000\u08f1\u08f2\u0005\u016d\u0000"+ + "\u0000\u08f2\u08f4\u0005\u00d3\u0000\u0000\u08f3\u08f0\u0001\u0000\u0000"+ + "\u0000\u08f3\u08f4\u0001\u0000\u0000\u0000\u08f4\u08f5\u0001\u0000\u0000"+ + "\u0000\u08f5\u08f6\u0003\u01cc\u00e6\u0000\u08f6\u08f7\u0005\u00ec\u0000"+ + "\u0000\u08f7\u08f8\u0003\u01cc\u00e6\u0000\u08f8\u08fa\u0001\u0000\u0000"+ + "\u0000\u08f9\u08e2\u0001\u0000\u0000\u0000\u08f9\u08ee\u0001\u0000\u0000"+ + "\u0000\u08fa{\u0001\u0000\u0000\u0000\u08fb\u08fd\u0005~\u0000\u0000\u08fc"+ + "\u08fe\u0005\u009b\u0000\u0000\u08fd\u08fc\u0001\u0000\u0000\u0000\u08fd"+ + "\u08fe\u0001\u0000\u0000\u0000\u08fe\u08ff\u0001\u0000\u0000\u0000\u08ff"+ + "\u0900\u0005u\u0000\u0000\u0900\u0901\u0003\u0202\u0101\u0000\u0901\u0902"+ + "\u0005\u00e3\u0000\u0000\u0902\u0903\u0005\u0309\u0000\u0000\u0903\u0904"+ + "\u0005\u0247\u0000\u0000\u0904\u0905\u0005\u0309\u0000\u0000\u0905\u0906"+ + "\u0005\u00ec\u0000\u0000\u0906\u0907\u0003\u01cc\u00e6\u0000\u0907}\u0001"+ + "\u0000\u0000\u0000\u0908\u0909\u0005~\u0000\u0000\u0909\u090a\u0005\u0092"+ + "\u0000\u0000\u090a\u090c\u0003\u01cc\u00e6\u0000\u090b\u090d\u0005\u0287"+ + "\u0000\u0000\u090c\u090b\u0001\u0000\u0000\u0000\u090c\u090d\u0001\u0000"+ + "\u0000\u0000\u090d\u0911\u0001\u0000\u0000\u0000\u090e\u090f\u0005\u0193"+ + "\u0000\u0000\u090f\u0910\u0005\u0318\u0000\u0000\u0910\u0912\u0003\u01cc"+ + "\u00e6\u0000\u0911\u090e\u0001\u0000\u0000\u0000\u0911\u0912\u0001\u0000"+ + "\u0000\u0000\u0912\u0916\u0001\u0000\u0000\u0000\u0913\u0914\u0005\u023c"+ + "\u0000\u0000\u0914\u0915\u0005\u0318\u0000\u0000\u0915\u0917\u0003\u01cc"+ + "\u00e6\u0000\u0916\u0913\u0001\u0000\u0000\u0000\u0916\u0917\u0001\u0000"+ + "\u0000\u0000\u0917\u091b\u0001\u0000\u0000\u0000\u0918\u0919\u0005\u00c4"+ + "\u0000\u0000\u0919\u091a\u0005\u0318\u0000\u0000\u091a\u091c\u0003\u01cc"+ + "\u00e6\u0000\u091b\u0918\u0001\u0000\u0000\u0000\u091b\u091c\u0001\u0000"+ + "\u0000\u0000\u091c\u0920\u0001\u0000\u0000\u0000\u091d\u091e\u0005\u02b5"+ + "\u0000\u0000\u091e\u091f\u0005\u0318\u0000\u0000\u091f\u0921\u0003\u01cc"+ + "\u00e6\u0000\u0920\u091d\u0001\u0000\u0000\u0000\u0920\u0921\u0001\u0000"+ + "\u0000\u0000\u0921\u0925\u0001\u0000\u0000\u0000\u0922\u0923\u0005\u02b6"+ + "\u0000\u0000\u0923\u0924\u0005\u0318\u0000\u0000\u0924\u0926\u0003\u01cc"+ + "\u00e6\u0000\u0925\u0922\u0001\u0000\u0000\u0000\u0925\u0926\u0001\u0000"+ + "\u0000\u0000\u0926\u092a\u0001\u0000\u0000\u0000\u0927\u0928\u0005\u023a"+ + "\u0000\u0000\u0928\u0929\u0005\u0318\u0000\u0000\u0929\u092b\u0003\u01cc"+ + "\u00e6\u0000\u092a\u0927\u0001\u0000\u0000\u0000\u092a\u092b\u0001\u0000"+ + "\u0000\u0000\u092b\u092f\u0001\u0000\u0000\u0000\u092c\u092d\u0005\u02b9"+ + "\u0000\u0000\u092d\u092e\u0005\u0318\u0000\u0000\u092e\u0930\u0003\u01cc"+ + "\u00e6\u0000\u092f\u092c\u0001\u0000\u0000\u0000\u092f\u0930\u0001\u0000"+ + "\u0000\u0000\u0930\u0935\u0001\u0000\u0000\u0000\u0931\u0932\u0005k\u0000"+ + "\u0000\u0932\u0933\u0005\u0136\u0000\u0000\u0933\u0934\u0005\u0318\u0000"+ + "\u0000\u0934\u0936\u0005\u0306\u0000\u0000\u0935\u0931\u0001\u0000\u0000"+ + "\u0000\u0935\u0936\u0001\u0000\u0000\u0000\u0936\u093a\u0001\u0000\u0000"+ + "\u0000\u0937\u0938\u0005\u02ba\u0000\u0000\u0938\u0939\u0005\u0318\u0000"+ + "\u0000\u0939\u093b\u0005\u0306\u0000\u0000\u093a\u0937\u0001\u0000\u0000"+ + "\u0000\u093a\u093b\u0001\u0000\u0000\u0000\u093b\u007f\u0001\u0000\u0000"+ + "\u0000\u093c\u093d\u0005m\u0000\u0000\u093d\u093f\u0003\u01cc\u00e6\u0000"+ + "\u093e\u093c\u0001\u0000\u0000\u0000\u093e\u093f\u0001\u0000\u0000\u0000"+ + "\u093f\u0948\u0001\u0000\u0000\u0000\u0940\u0941\u0005\u016d\u0000\u0000"+ + "\u0941\u0949\u0005\u0172\u0000\u0000\u0942\u0949\u0005\u0172\u0000\u0000"+ + "\u0943\u0944\u0005N\u0000\u0000\u0944\u0945\u0005\u02ff\u0000\u0000\u0945"+ + "\u0946\u0003\u01b0\u00d8\u0000\u0946\u0947\u0005\u0300\u0000\u0000\u0947"+ + "\u0949\u0001\u0000\u0000\u0000\u0948\u0940\u0001\u0000\u0000\u0000\u0948"+ + "\u0942\u0001\u0000\u0000\u0000\u0948\u0943\u0001\u0000\u0000\u0000\u0949"+ + "\u0081\u0001\u0000\u0000\u0000\u094a\u094b\u0005~\u0000\u0000\u094b\u094c"+ + "\u0005\u00ba\u0000\u0000\u094c\u094e\u0003\u01cc\u00e6\u0000\u094d\u094f"+ + "\u0005\u001b\u0000\u0000\u094e\u094d\u0001\u0000\u0000\u0000\u094e\u094f"+ + "\u0001\u0000\u0000\u0000\u094f\u0950\u0001\u0000\u0000\u0000\u0950\u0958"+ + "\u0003\u01d8\u00ec\u0000\u0951\u0952\u0005X\u0000\u0000\u0952\u0957\u0003"+ + "\u01cc\u00e6\u0000\u0953\u0954\u0005\u009b\u0000\u0000\u0954\u0957\u0003"+ + "\u01b0\u00d8\u0000\u0955\u0957\u0003\u0080@\u0000\u0956\u0951\u0001\u0000"+ + "\u0000\u0000\u0956\u0953\u0001\u0000\u0000\u0000\u0956\u0955\u0001\u0000"+ + "\u0000\u0000\u0957\u095a\u0001\u0000\u0000\u0000\u0958\u0956\u0001\u0000"+ + "\u0000\u0000\u0958\u0959\u0001\u0000\u0000\u0000\u0959\u0083\u0001\u0000"+ + "\u0000\u0000\u095a\u0958\u0001\u0000\u0000\u0000\u095b\u095c\u0003\u0202"+ + "\u0101\u0000\u095c\u095d\u0005\u0109\u0000\u0000\u095d\u095e\u0005\u02ff"+ + "\u0000\u0000\u095e\u0963\u0005\u0309\u0000\u0000\u095f\u0960\u0005\u02f9"+ + "\u0000\u0000\u0960\u0962\u0005\u0309\u0000\u0000\u0961\u095f\u0001\u0000"+ + "\u0000\u0000\u0962\u0965\u0001\u0000\u0000\u0000\u0963\u0961\u0001\u0000"+ + "\u0000\u0000\u0963\u0964\u0001\u0000\u0000\u0000\u0964\u0966\u0001\u0000"+ + "\u0000\u0000\u0965\u0963\u0001\u0000\u0000\u0000\u0966\u096b\u0005\u0300"+ + "\u0000\u0000\u0967\u0968\u0005\u0017\u0000\u0000\u0968\u096a\u0003\u0084"+ + "B\u0000\u0969\u0967\u0001\u0000\u0000\u0000\u096a\u096d\u0001\u0000\u0000"+ + "\u0000\u096b\u0969\u0001\u0000\u0000\u0000\u096b\u096c\u0001\u0000\u0000"+ + "\u0000\u096c\u0085\u0001\u0000\u0000\u0000\u096d\u096b\u0001\u0000\u0000"+ + "\u0000\u096e\u096f\u0005~\u0000\u0000\u096f\u0970\u0005\u02bb\u0000\u0000"+ + "\u0970\u0971\u0005\u0254\u0000\u0000\u0971\u0972\u0003\u0202\u0101\u0000"+ + "\u0972\u0973\u0005\u0180\u0000\u0000\u0973\u0976\u0003\u0202\u0101\u0000"+ + "\u0974\u0975\u0005\u0282\u0000\u0000\u0975\u0977\u0003\u0084B\u0000\u0976"+ + "\u0974\u0001\u0000\u0000\u0000\u0976\u0977\u0001\u0000\u0000\u0000\u0977"+ + "\u0978\u0001\u0000\u0000\u0000\u0978\u0979\u0005\u00d1\u0000\u0000\u0979"+ + "\u097a\u0005\u01b8\u0000\u0000\u097a\u097b\u0003\u0202\u0101\u0000\u097b"+ + "\u097c\u0005\u02ff\u0000\u0000\u097c\u097d\u0005\u0300\u0000\u0000\u097d"+ + "\u0087\u0001\u0000\u0000\u0000\u097e\u097f\u0003\u01cc\u00e6\u0000\u097f"+ + "\u0984\u0005\u0309\u0000\u0000\u0980\u0981\u0005\u02f9\u0000\u0000\u0981"+ + "\u0983\u0003\u0088D\u0000\u0982\u0980\u0001\u0000\u0000\u0000\u0983\u0986"+ + "\u0001\u0000\u0000\u0000\u0984\u0982\u0001\u0000\u0000\u0000\u0984\u0985"+ + "\u0001\u0000\u0000\u0000\u0985\u0089\u0001\u0000\u0000\u0000\u0986\u0984"+ + "\u0001\u0000\u0000\u0000\u0987\u0988\u0005~\u0000\u0000\u0988\u0989\u0005"+ + "\u00e5\u0000\u0000\u0989\u098a\u0005\u0091\u0000\u0000\u098a\u098b\u0005"+ + "\u02bc\u0000\u0000\u098b\u0992\u0003\u0202\u0101\u0000\u098c\u098d\u0005"+ + "\u00fc\u0000\u0000\u098d\u0991\u0003\u0202\u0101\u0000\u098e\u098f\u0005"+ + "\u0167\u0000\u0000\u098f\u0991\u0005\u00fc\u0000\u0000\u0990\u098c\u0001"+ + "\u0000\u0000\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\u0999\u0001\u0000\u0000\u0000\u0994\u0992\u0001"+ + "\u0000\u0000\u0000\u0995\u0996\u0005\u0276\u0000\u0000\u0996\u099a\u0003"+ + "\u0202\u0101\u0000\u0997\u0998\u0005\u0167\u0000\u0000\u0998\u099a\u0005"+ + "\u0276\u0000\u0000\u0999\u0995\u0001\u0000\u0000\u0000\u0999\u0997\u0001"+ + "\u0000\u0000\u0000\u0999\u099a\u0001\u0000\u0000\u0000\u099a\u09a0\u0001"+ + "\u0000\u0000\u0000\u099b\u099c\u0005\u0186\u0000\u0000\u099c\u099d\u0005"+ + "\u02ff\u0000\u0000\u099d\u099e\u0003\u0088D\u0000\u099e\u099f\u0005\u0300"+ + "\u0000\u0000\u099f\u09a1\u0001\u0000\u0000\u0000\u09a0\u099b\u0001\u0000"+ + "\u0000\u0000\u09a0\u09a1\u0001\u0000\u0000\u0000\u09a1\u008b\u0001\u0000"+ + "\u0000\u0000\u09a2\u09a3\u0005~\u0000\u0000\u09a3\u09a4\u0005\u00e5\u0000"+ + "\u0000\u09a4\u09a8\u0005\u0237\u0000\u0000\u09a5\u09a6\u0005\u02b3\u0000"+ + "\u0000\u09a6\u09a7\u0005\u016d\u0000\u0000\u09a7\u09a9\u0005\u00d3\u0000"+ + "\u0000\u09a8\u09a5\u0001\u0000\u0000\u0000\u09a8\u09a9\u0001\u0000\u0000"+ + "\u0000\u09a9\u09aa\u0001\u0000\u0000\u0000\u09aa\u09ab\u0003\u0202\u0101"+ + "\u0000\u09ab\u09ac\u0005\u02ff\u0000\u0000\u09ac\u09ad\u0003\u0202\u0101"+ + "\u0000\u09ad\u09b3\u0003\u0202\u0101\u0000\u09ae\u09af\u0005\u0186\u0000"+ + "\u0000\u09af\u09b0\u0005\u02ff\u0000\u0000\u09b0\u09b1\u0003\u0088D\u0000"+ + "\u09b1\u09b2\u0005\u0300\u0000\u0000\u09b2\u09b4\u0001\u0000\u0000\u0000"+ + "\u09b3\u09ae\u0001\u0000\u0000\u0000\u09b3\u09b4\u0001\u0000\u0000\u0000"+ + "\u09b4\u09b7\u0001\u0000\u0000\u0000\u09b5\u09b6\u0005X\u0000\u0000\u09b6"+ + "\u09b8\u0003v;\u0000\u09b7\u09b5\u0001\u0000\u0000\u0000\u09b7\u09b8\u0001"+ + "\u0000\u0000\u0000\u09b8\u09b9\u0001\u0000\u0000\u0000\u09b9\u09bc\u0005"+ + "\u0300\u0000\u0000\u09ba\u09bb\u0005\u010f\u0000\u0000\u09bb\u09bd\u0003"+ + "\u01ce\u00e7\u0000\u09bc\u09ba\u0001\u0000\u0000\u0000\u09bc\u09bd\u0001"+ + "\u0000\u0000\u0000\u09bd\u09be\u0001\u0000\u0000\u0000\u09be\u09bf\u0005"+ + "\u02bd\u0000\u0000\u09bf\u09c5\u0003\u01cc\u00e6\u0000\u09c0\u09c1\u0005"+ + "\u0186\u0000\u0000\u09c1\u09c2\u0005\u02ff\u0000\u0000\u09c2\u09c3\u0003"+ + "\u0088D\u0000\u09c3\u09c4\u0005\u0300\u0000\u0000\u09c4\u09c6\u0001\u0000"+ + "\u0000\u0000\u09c5\u09c0\u0001\u0000\u0000\u0000\u09c5\u09c6\u0001\u0000"+ + "\u0000\u0000\u09c6\u008d\u0001\u0000\u0000\u0000\u09c7\u09ca\u0005~\u0000"+ + "\u0000\u09c8\u09c9\u0005\u0187\u0000\u0000\u09c9\u09cb\u0005\u01d6\u0000"+ + "\u0000\u09ca\u09c8\u0001\u0000\u0000\u0000\u09ca\u09cb\u0001\u0000\u0000"+ + "\u0000\u09cb\u09cc\u0001\u0000\u0000\u0000\u09cc\u09cd\u0005\u00ee\u0000"+ + "\u0000\u09cd\u09ce\u0003\u01cc\u00e6\u0000\u09ce\u008f\u0001\u0000\u0000"+ + "\u0000\u09cf\u09d0\u0005~\u0000\u0000\u09d0\u09d1\u0005\u00fa\u0000\u0000"+ + "\u09d1\u09fb\u0003\u0202\u0101\u0000\u09d2\u09d4\u0005\u0287\u0000\u0000"+ + "\u09d3\u09d2\u0001\u0000\u0000\u0000\u09d3\u09d4\u0001\u0000\u0000\u0000"+ + "\u09d4\u09f7\u0001\u0000\u0000\u0000\u09d5\u09f8\u0005\u0290\u0000\u0000"+ + "\u09d6\u09f8\u0005\u0291\u0000\u0000\u09d7\u09f8\u0005\u007f\u0000\u0000"+ + "\u09d8\u09f8\u0005\u0168\u0000\u0000\u09d9\u09f8\u0005\u0292\u0000\u0000"+ + "\u09da\u09f8\u0005\u0293\u0000\u0000\u09db\u09f8\u0005\u0080\u0000\u0000"+ + "\u09dc\u09f8\u0005\u0169\u0000\u0000\u09dd\u09f8\u0005\u0294\u0000\u0000"+ + "\u09de\u09f8\u0005\u0295\u0000\u0000\u09df\u09f8\u0005\u0296\u0000\u0000"+ + "\u09e0\u09f8\u0005\u0297\u0000\u0000\u09e1\u09e3\u0007\b\u0000\u0000\u09e2"+ + "\u09e1\u0001\u0000\u0000\u0000\u09e2\u09e3\u0001\u0000\u0000\u0000\u09e3"+ + "\u09e4\u0001\u0000\u0000\u0000\u09e4\u09e5\u0005\u01a1\u0000\u0000\u09e5"+ + "\u09f8\u0007\t\u0000\u0000\u09e6\u09e7\u0005\u0274\u0000\u0000\u09e7\u09e8"+ + "\u0005\u0269\u0000\u0000\u09e8\u09f8\u0005\u0309\u0000\u0000\u09e9\u09ea"+ + "\u0005\u0109\u0000\u0000\u09ea\u09eb\u0005\u01e5\u0000\u0000\u09eb\u09f8"+ + "\u0003\u01ce\u00e7\u0000\u09ec\u09ed\u0005\u0109\u0000\u0000\u09ed\u09ee"+ + "\u0005\u00fa\u0000\u0000\u09ee\u09f8\u0003\u01ce\u00e7\u0000\u09ef\u09f0"+ + "\u0005\u01e5\u0000\u0000\u09f0\u09f8\u0003\u01ce\u00e7\u0000\u09f1\u09f2"+ + "\u0005\f\u0000\u0000\u09f2\u09f8\u0003\u01ce\u00e7\u0000\u09f3\u09f4\u0005"+ + "\u026d\u0000\u0000\u09f4\u09f8\u0003\u01ce\u00e7\u0000\u09f5\u09f6\u0005"+ + "\u0234\u0000\u0000\u09f6\u09f8\u0005\u0306\u0000\u0000\u09f7\u09d5\u0001"+ + "\u0000\u0000\u0000\u09f7\u09d6\u0001\u0000\u0000\u0000\u09f7\u09d7\u0001"+ + "\u0000\u0000\u0000\u09f7\u09d8\u0001\u0000\u0000\u0000\u09f7\u09d9\u0001"+ + "\u0000\u0000\u0000\u09f7\u09da\u0001\u0000\u0000\u0000\u09f7\u09db\u0001"+ + "\u0000\u0000\u0000\u09f7\u09dc\u0001\u0000\u0000\u0000\u09f7\u09dd\u0001"+ + "\u0000\u0000\u0000\u09f7\u09de\u0001\u0000\u0000\u0000\u09f7\u09df\u0001"+ + "\u0000\u0000\u0000\u09f7\u09e0\u0001\u0000\u0000\u0000\u09f7\u09e2\u0001"+ + "\u0000\u0000\u0000\u09f7\u09e6\u0001\u0000\u0000\u0000\u09f7\u09e9\u0001"+ + "\u0000\u0000\u0000\u09f7\u09ec\u0001\u0000\u0000\u0000\u09f7\u09ef\u0001"+ + "\u0000\u0000\u0000\u09f7\u09f1\u0001\u0000\u0000\u0000\u09f7\u09f3\u0001"+ + "\u0000\u0000\u0000\u09f7\u09f5\u0001\u0000\u0000\u0000\u09f8\u09f9\u0001"+ + "\u0000\u0000\u0000\u09f9\u09f7\u0001\u0000\u0000\u0000\u09f9\u09fa\u0001"+ + "\u0000\u0000\u0000\u09fa\u09fc\u0001\u0000\u0000\u0000\u09fb\u09d3\u0001"+ + "\u0000\u0000\u0000\u09fb\u09fc\u0001\u0000\u0000\u0000\u09fc\u0091\u0001"+ + "\u0000\u0000\u0000\u09fd\u09ff\u0005~\u0000\u0000\u09fe\u0a00\u0005\u0263"+ + "\u0000\u0000\u09ff\u09fe\u0001\u0000\u0000\u0000\u09ff\u0a00\u0001\u0000"+ + "\u0000\u0000\u0a00\u0a01\u0001\u0000\u0000\u0000\u0a01\u0a03\u0005\u010c"+ + "\u0000\u0000\u0a02\u0a04\u0005\u02c4\u0000\u0000\u0a03\u0a02\u0001\u0000"+ + "\u0000\u0000\u0a03\u0a04\u0001\u0000\u0000\u0000\u0a04\u0a0b\u0001\u0000"+ + "\u0000\u0000\u0a05\u0a06\u0005\u02b3\u0000\u0000\u0a06\u0a07\u0005\u016d"+ + "\u0000\u0000\u0a07\u0a09\u0005\u00d3\u0000\u0000\u0a08\u0a05\u0001\u0000"+ + "\u0000\u0000\u0a08\u0a09\u0001\u0000\u0000\u0000\u0a09\u0a0a\u0001\u0000"+ + "\u0000\u0000\u0a0a\u0a0c\u0003\u0202\u0101\u0000\u0a0b\u0a08\u0001\u0000"+ + "\u0000\u0000\u0a0b\u0a0c\u0001\u0000\u0000\u0000\u0a0c\u0a0d\u0001\u0000"+ + "\u0000\u0000\u0a0d\u0a0e\u0005\u0180\u0000\u0000\u0a0e\u0a11\u0003\u0202"+ + "\u0101\u0000\u0a0f\u0a10\u0005\u0272\u0000\u0000\u0a10\u0a12\u0003\u01dc"+ + "\u00ee\u0000\u0a11\u0a0f\u0001\u0000\u0000\u0000\u0a11\u0a12\u0001\u0000"+ + "\u0000\u0000\u0a12\u0a15\u0001\u0000\u0000\u0000\u0a13\u0a14\u0005\u023a"+ + "\u0000\u0000\u0a14\u0a16\u0003\u0202\u0101\u0000\u0a15\u0a13\u0001\u0000"+ + "\u0000\u0000\u0a15\u0a16\u0001\u0000\u0000\u0000\u0a16\u0a19\u0001\u0000"+ + "\u0000\u0000\u0a17\u0a18\u0005\u0284\u0000\u0000\u0a18\u0a1a\u0003\u01ec"+ + "\u00f6\u0000\u0a19\u0a17\u0001\u0000\u0000\u0000\u0a19\u0a1a\u0001\u0000"+ + "\u0000\u0000\u0a1a\u0093\u0001\u0000\u0000\u0000\u0a1b\u0a1e\u0005~\u0000"+ + "\u0000\u0a1c\u0a1d\u0005\u0187\u0000\u0000\u0a1d\u0a1f\u0005\u01d6\u0000"+ + "\u0000\u0a1e\u0a1c\u0001\u0000\u0000\u0000\u0a1e\u0a1f\u0001\u0000\u0000"+ + "\u0000\u0a1f\u0a21\u0001\u0000\u0000\u0000\u0a20\u0a22\u0005\u01b7\u0000"+ + "\u0000\u0a21\u0a20\u0001\u0000\u0000\u0000\u0a21\u0a22\u0001\u0000\u0000"+ + "\u0000\u0a22\u0a23\u0001\u0000\u0000\u0000\u0a23\u0a24\u0005\u012b\u0000"+ + "\u0000\u0a24\u0a3d\u0003\u0202\u0101\u0000\u0a25\u0a28\u0005~\u0000\u0000"+ + "\u0a26\u0a27\u0005\u0187\u0000\u0000\u0a27\u0a29\u0005\u01d6\u0000\u0000"+ + "\u0a28\u0a26\u0001\u0000\u0000\u0000\u0a28\u0a29\u0001\u0000\u0000\u0000"+ + "\u0a29\u0a2b\u0001\u0000\u0000\u0000\u0a2a\u0a2c\u0005\u025b\u0000\u0000"+ + "\u0a2b\u0a2a\u0001\u0000\u0000\u0000\u0a2b\u0a2c\u0001\u0000\u0000\u0000"+ + "\u0a2c\u0a2e\u0001\u0000\u0000\u0000\u0a2d\u0a2f\u0005\u01b7\u0000\u0000"+ + "\u0a2e\u0a2d\u0001\u0000\u0000\u0000\u0a2e\u0a2f\u0001\u0000\u0000\u0000"+ + "\u0a2f\u0a30\u0001\u0000\u0000\u0000\u0a30\u0a31\u0005\u012b\u0000\u0000"+ + "\u0a31\u0a32\u0003\u0202\u0101\u0000\u0a32\u0a33\u0005\u00fc\u0000\u0000"+ + "\u0a33\u0a36\u0003\u0202\u0101\u0000\u0a34\u0a35\u0005\u02c5\u0000\u0000"+ + "\u0a35\u0a37\u0003\u0202\u0101\u0000\u0a36\u0a34\u0001\u0000\u0000\u0000"+ + "\u0a36\u0a37\u0001\u0000\u0000\u0000\u0a37\u0a3a\u0001\u0000\u0000\u0000"+ + "\u0a38\u0a39\u0005\u0276\u0000\u0000\u0a39\u0a3b\u0003\u0202\u0101\u0000"+ + "\u0a3a\u0a38\u0001\u0000\u0000\u0000\u0a3a\u0a3b\u0001\u0000\u0000\u0000"+ + "\u0a3b\u0a3d\u0001\u0000\u0000\u0000\u0a3c\u0a1b\u0001\u0000\u0000\u0000"+ + "\u0a3c\u0a25\u0001\u0000\u0000\u0000\u0a3d\u0095\u0001\u0000\u0000\u0000"+ + "\u0a3e\u0a3f\u0005~\u0000\u0000\u0a3f\u0a40\u0005\u02c6\u0000\u0000\u0a40"+ + "\u0a44\u0005\u0280\u0000\u0000\u0a41\u0a42\u0005\u02b3\u0000\u0000\u0a42"+ + "\u0a43\u0005\u016d\u0000\u0000\u0a43\u0a45\u0005\u00d3\u0000\u0000\u0a44"+ + "\u0a41\u0001\u0000\u0000\u0000\u0a44\u0a45\u0001\u0000\u0000\u0000\u0a45"+ + "\u0a46\u0001\u0000\u0000\u0000\u0a46\u0a4b\u0003\u0202\u0101\u0000\u0a47"+ + "\u0a48\u0005\u02ff\u0000\u0000\u0a48\u0a49\u0003\u01d0\u00e8\u0000\u0a49"+ + "\u0a4a\u0005\u0300\u0000\u0000\u0a4a\u0a4c\u0001\u0000\u0000\u0000\u0a4b"+ + "\u0a47\u0001\u0000\u0000\u0000\u0a4b\u0a4c\u0001\u0000\u0000\u0000\u0a4c"+ + "\u0a4e\u0001\u0000\u0000\u0000\u0a4d\u0a4f\u0005\u0287\u0000\u0000\u0a4e"+ + "\u0a4d\u0001\u0000\u0000\u0000\u0a4e\u0a4f\u0001\u0000\u0000\u0000\u0a4f"+ + "\u0a52\u0001\u0000\u0000\u0000\u0a50\u0a51\u0005\u023a\u0000\u0000\u0a51"+ + "\u0a53\u0003\u0202\u0101\u0000\u0a52\u0a50\u0001\u0000\u0000\u0000\u0a52"+ + "\u0a53\u0001\u0000\u0000\u0000\u0a53\u0a54\u0001\u0000\u0000\u0000\u0a54"+ + "\u0a55\u0005\u001b\u0000\u0000\u0a55\u0a5b\u0003\u0158\u00ac\u0000\u0a56"+ + "\u0a58\u0005\u0287\u0000\u0000\u0a57\u0a59\u0005\u0167\u0000\u0000\u0a58"+ + "\u0a57\u0001\u0000\u0000\u0000\u0a58\u0a59\u0001\u0000\u0000\u0000\u0a59"+ + "\u0a5a\u0001\u0000\u0000\u0000\u0a5a\u0a5c\u0005\u0091\u0000\u0000\u0a5b"+ + "\u0a56\u0001\u0000\u0000\u0000\u0a5b\u0a5c\u0001\u0000\u0000\u0000\u0a5c"+ + "\u0097\u0001\u0000\u0000\u0000\u0a5d\u0a5e\u0005~\u0000\u0000\u0a5e\u0a5f"+ + "\u0005\u0184\u0000\u0000\u0a5f\u0a60\u0003\u0202\u0101\u0000\u0a60\u0a61"+ + "\u0005\u02ff\u0000\u0000\u0a61\u0a62\u0005\u01b8\u0000\u0000\u0a62\u0a63"+ + "\u0005\u0318\u0000\u0000\u0a63\u0a68\u0003\u0202\u0101\u0000\u0a64\u0a65"+ + "\u0005\u02f9\u0000\u0000\u0a65\u0a66\u0005\u02c7\u0000\u0000\u0a66\u0a67"+ + "\u0005\u0318\u0000\u0000\u0a67\u0a69\u0003\u01cc\u00e6\u0000\u0a68\u0a64"+ + "\u0001\u0000\u0000\u0000\u0a68\u0a69\u0001\u0000\u0000\u0000\u0a69\u0a6e"+ + "\u0001\u0000\u0000\u0000\u0a6a\u0a6b\u0005\u02f9\u0000\u0000\u0a6b\u0a6c"+ + "\u0005\u02c8\u0000\u0000\u0a6c\u0a6d\u0005\u0318\u0000\u0000\u0a6d\u0a6f"+ + "\u0003\u01cc\u00e6\u0000\u0a6e\u0a6a\u0001\u0000\u0000\u0000\u0a6e\u0a6f"+ + "\u0001\u0000\u0000\u0000\u0a6f\u0a74\u0001\u0000\u0000\u0000\u0a70\u0a71"+ + "\u0005\u02f9\u0000\u0000\u0a71\u0a72\u0005\u02c9\u0000\u0000\u0a72\u0a73"+ + "\u0005\u0318\u0000\u0000\u0a73\u0a75\u0003\u01cc\u00e6\u0000\u0a74\u0a70"+ + "\u0001\u0000\u0000\u0000\u0a74\u0a75\u0001\u0000\u0000\u0000\u0a75\u0a7a"+ + "\u0001\u0000\u0000\u0000\u0a76\u0a77\u0005\u02f9\u0000\u0000\u0a77\u0a78"+ + "\u0005\u02ca\u0000\u0000\u0a78\u0a79\u0005\u0318\u0000\u0000\u0a79\u0a7b"+ + "\u0003\u01cc\u00e6\u0000\u0a7a\u0a76\u0001\u0000\u0000\u0000\u0a7a\u0a7b"+ + "\u0001\u0000\u0000\u0000\u0a7b\u0a80\u0001\u0000\u0000\u0000\u0a7c\u0a7d"+ + "\u0005\u02f9\u0000\u0000\u0a7d\u0a7e\u0005\u01da\u0000\u0000\u0a7e\u0a7f"+ + "\u0005\u0318\u0000\u0000\u0a7f\u0a81\u0003\u01cc\u00e6\u0000\u0a80\u0a7c"+ + "\u0001\u0000\u0000\u0000\u0a80\u0a81\u0001\u0000\u0000\u0000\u0a81\u0a86"+ + "\u0001\u0000\u0000\u0000\u0a82\u0a83\u0005\u02f9\u0000\u0000\u0a83\u0a84"+ + "\u0005\u0124\u0000\u0000\u0a84\u0a85\u0005\u0318\u0000\u0000\u0a85\u0a87"+ + "\u0003\u01cc\u00e6\u0000\u0a86\u0a82\u0001\u0000\u0000\u0000\u0a86\u0a87"+ + "\u0001\u0000\u0000\u0000\u0a87\u0a8a\u0001\u0000\u0000\u0000\u0a88\u0a89"+ + "\u0005\u02f9\u0000\u0000\u0a89\u0a8b\u0005\u02cb\u0000\u0000\u0a8a\u0a88"+ + "\u0001\u0000\u0000\u0000\u0a8a\u0a8b\u0001\u0000\u0000\u0000\u0a8b\u0a8e"+ + "\u0001\u0000\u0000\u0000\u0a8c\u0a8d\u0005\u02f9\u0000\u0000\u0a8d\u0a8f"+ + "\u0005\u02cc\u0000\u0000\u0a8e\u0a8c\u0001\u0000\u0000\u0000\u0a8e\u0a8f"+ + "\u0001\u0000\u0000\u0000\u0a8f\u0a90\u0001\u0000\u0000\u0000\u0a90\u0a91"+ + "\u0005\u0300\u0000\u0000\u0a91\u0099\u0001\u0000\u0000\u0000\u0a92\u0a93"+ + "\u0005\u0184\u0000\u0000\u0a93\u0a94\u0005\u0306\u0000\u0000\u0a94\u0a9b"+ + "\u0003\u0202\u0101\u0000\u0a95\u0a96\u0005\u02ff\u0000\u0000\u0a96\u0a97"+ + "\u0003\u0202\u0101\u0000\u0a97\u0a98\u0005\u02f9\u0000\u0000\u0a98\u0a99"+ + "\u0003\u0202\u0101\u0000\u0a99\u0a9a\u0005\u0300\u0000\u0000\u0a9a\u0a9c"+ + "\u0001\u0000\u0000\u0000\u0a9b\u0a95\u0001\u0000\u0000\u0000\u0a9b\u0a9c"+ + "\u0001\u0000\u0000\u0000\u0a9c\u0ab1\u0001\u0000\u0000\u0000\u0a9d\u0a9e"+ + "\u0005\u00ee\u0000\u0000\u0a9e\u0aa7\u0005\u0306\u0000\u0000\u0a9f\u0aa0"+ + "\u0005\u02ff\u0000\u0000\u0aa0\u0aa3\u0003\u0202\u0101\u0000\u0aa1\u0aa2"+ + "\u0005\u02f9\u0000\u0000\u0aa2\u0aa4\u0003\u0202\u0101\u0000\u0aa3\u0aa1"+ + "\u0001\u0000\u0000\u0000\u0aa3\u0aa4\u0001\u0000\u0000\u0000\u0aa4\u0aa5"+ + "\u0001\u0000\u0000\u0000\u0aa5\u0aa6\u0005\u0300\u0000\u0000\u0aa6\u0aa8"+ + "\u0001\u0000\u0000\u0000\u0aa7\u0a9f\u0001\u0000\u0000\u0000\u0aa7\u0aa8"+ + "\u0001\u0000\u0000\u0000\u0aa8\u0aa9\u0001\u0000\u0000\u0000\u0aa9\u0aaa"+ + "\u0003\u0202\u0101\u0000\u0aaa\u0aab\u0005\u02ff\u0000\u0000\u0aab\u0aac"+ + "\u0003\u01da\u00ed\u0000\u0aac\u0aad\u0005\u0300\u0000\u0000\u0aad\u0ab1"+ + "\u0001\u0000\u0000\u0000\u0aae\u0aaf\u0005\u0229\u0000\u0000\u0aaf\u0ab1"+ + "\u0003\u0202\u0101\u0000\u0ab0\u0a92\u0001\u0000\u0000\u0000\u0ab0\u0a9d"+ + "\u0001\u0000\u0000\u0000\u0ab0\u0aae\u0001\u0000\u0000\u0000\u0ab1\u009b"+ + "\u0001\u0000\u0000\u0000\u0ab2\u0ab3\u0005~\u0000\u0000\u0ab3\u0ab4\u0005"+ + "\u0184\u0000\u0000\u0ab4\u0ab5\u0005Q\u0000\u0000\u0ab5\u0ab7\u0003\u0202"+ + "\u0101\u0000\u0ab6\u0ab8\u0005\u009b\u0000\u0000\u0ab7\u0ab6\u0001\u0000"+ + "\u0000\u0000\u0ab7\u0ab8\u0001\u0000\u0000\u0000\u0ab8\u0ab9\u0001\u0000"+ + "\u0000\u0000\u0ab9\u0aba\u0005\u00e3\u0000\u0000\u0aba\u0abb\u0005\u025c"+ + "\u0000\u0000\u0abb\u0abc\u0003\u0202\u0101\u0000\u0abc\u0abd\u0005\u0272"+ + "\u0000\u0000\u0abd\u0ac0\u0003\u01dc\u00ee\u0000\u0abe\u0abf\u0005\u02cd"+ + "\u0000\u0000\u0abf\u0ac1\u0003\u0202\u0101\u0000\u0ac0\u0abe\u0001\u0000"+ + "\u0000\u0000\u0ac0\u0ac1\u0001\u0000\u0000\u0000\u0ac1\u0ac2\u0001\u0000"+ + "\u0000\u0000\u0ac2\u0ac3\u0005\u001b\u0000\u0000\u0ac3\u0ac8\u0003\u009a"+ + "M\u0000\u0ac4\u0ac5\u0005\u02f9\u0000\u0000\u0ac5\u0ac7\u0003\u009aM\u0000"+ + "\u0ac6\u0ac4\u0001\u0000\u0000\u0000\u0ac7\u0aca\u0001\u0000\u0000\u0000"+ + "\u0ac8\u0ac6\u0001\u0000\u0000\u0000\u0ac8\u0ac9\u0001\u0000\u0000\u0000"+ + "\u0ac9\u009d\u0001\u0000\u0000\u0000\u0aca\u0ac8\u0001\u0000\u0000\u0000"+ + "\u0acb\u0acc\u0005~\u0000\u0000\u0acc\u0acd\u0005\u0184\u0000\u0000\u0acd"+ + "\u0ace\u0005\u02cd\u0000\u0000\u0ace\u0acf\u0003\u0202\u0101\u0000\u0acf"+ + "\u0ad0\u0005\u0272\u0000\u0000\u0ad0\u0ad1\u0003\u01dc\u00ee\u0000\u0ad1"+ + "\u009f\u0001\u0000\u0000\u0000\u0ad2\u0ad3\u0005~\u0000\u0000\u0ad3\u0ad4"+ + "\u0005\u02ce\u0000\u0000\u0ad4\u0ad5\u0003\u0202\u0101\u0000\u0ad5\u0ad6"+ + "\u0005\u0180\u0000\u0000\u0ad6\u0ad9\u0003\u0202\u0101\u0000\u0ad7\u0ad8"+ + "\u0005\u00e3\u0000\u0000\u0ad8\u0ada\u0007\n\u0000\u0000\u0ad9\u0ad7\u0001"+ + "\u0000\u0000\u0000\u0ad9\u0ada\u0001\u0000\u0000\u0000\u0ada\u0add\u0001"+ + "\u0000\u0000\u0000\u0adb\u0adc\u0005\u0247\u0000\u0000\u0adc\u0ade\u0003"+ + "\u01fa\u00fd\u0000\u0add\u0adb\u0001\u0000\u0000\u0000\u0add\u0ade\u0001"+ + "\u0000\u0000\u0000\u0ade\u0ae4\u0001\u0000\u0000\u0000\u0adf\u0ae0\u0005"+ + "\u0272\u0000\u0000\u0ae0\u0ae1\u0005\u02ff\u0000\u0000\u0ae1\u0ae2\u0003"+ + "\u01ec\u00f6\u0000\u0ae2\u0ae3\u0005\u0300\u0000\u0000\u0ae3\u0ae5\u0001"+ + "\u0000\u0000\u0000\u0ae4\u0adf\u0001\u0000\u0000\u0000\u0ae4\u0ae5\u0001"+ + "\u0000\u0000\u0000\u0ae5\u0aec\u0001\u0000\u0000\u0000\u0ae6\u0ae7\u0005"+ + "\u0287\u0000\u0000\u0ae7\u0ae8\u0005N\u0000\u0000\u0ae8\u0ae9\u0005\u02ff"+ + "\u0000\u0000\u0ae9\u0aea\u0003\u01ec\u00f6\u0000\u0aea\u0aeb\u0005\u0300"+ + "\u0000\u0000\u0aeb\u0aed\u0001\u0000\u0000\u0000\u0aec\u0ae6\u0001\u0000"+ + "\u0000\u0000\u0aec\u0aed\u0001\u0000\u0000\u0000\u0aed\u00a1\u0001\u0000"+ + "\u0000\u0000\u0aee\u0aef\u0005~\u0000\u0000\u0aef\u0af0\u0005\u01e5\u0000"+ + "\u0000\u0af0\u0b1f\u0003\u01fa\u00fd\u0000\u0af1\u0af3\u0005\u0287\u0000"+ + "\u0000\u0af2\u0af1\u0001\u0000\u0000\u0000\u0af2\u0af3\u0001\u0000\u0000"+ + "\u0000\u0af3\u0b1b\u0001\u0000\u0000\u0000\u0af4\u0b1c\u0005\u0290\u0000"+ + "\u0000\u0af5\u0b1c\u0005\u0291\u0000\u0000\u0af6\u0b1c\u0005\u007f\u0000"+ + "\u0000\u0af7\u0b1c\u0005\u0168\u0000\u0000\u0af8\u0b1c\u0005\u0292\u0000"+ + "\u0000\u0af9\u0b1c\u0005\u0293\u0000\u0000\u0afa\u0b1c\u0005\u0294\u0000"+ + "\u0000\u0afb\u0b1c\u0005\u0295\u0000\u0000\u0afc\u0b1c\u0005\u0296\u0000"+ + "\u0000\u0afd\u0b1c\u0005\u0297\u0000\u0000\u0afe\u0b1c\u0005\u0298\u0000"+ + "\u0000\u0aff\u0b1c\u0005\u0299\u0000\u0000\u0b00\u0b1c\u0005\u029a\u0000"+ + "\u0000\u0b01\u0b1c\u0005\u029b\u0000\u0000\u0b02\u0b03\u0005k\u0000\u0000"+ + "\u0b03\u0b04\u0005\u0136\u0000\u0000\u0b04\u0b1c\u0005\u0306\u0000\u0000"+ + "\u0b05\u0b07\u0005\u00c5\u0000\u0000\u0b06\u0b05\u0001\u0000\u0000\u0000"+ + "\u0b06\u0b07\u0001\u0000\u0000\u0000\u0b07\u0b08\u0001\u0000\u0000\u0000"+ + "\u0b08\u0b09\u0005\u01a1\u0000\u0000\u0b09\u0b1c\u0007\t\u0000\u0000\u0b0a"+ + "\u0b0b\u0005\u0274\u0000\u0000\u0b0b\u0b0c\u0005\u0269\u0000\u0000\u0b0c"+ + "\u0b1c\u0005\u0309\u0000\u0000\u0b0d\u0b0e\u0005\u0109\u0000\u0000\u0b0e"+ + "\u0b0f\u0005\u01e5\u0000\u0000\u0b0f\u0b1c\u0003\u01ce\u00e7\u0000\u0b10"+ + "\u0b11\u0005\u0109\u0000\u0000\u0b11\u0b12\u0005\u00fa\u0000\u0000\u0b12"+ + "\u0b1c\u0003\u01ce\u00e7\u0000\u0b13\u0b14\u0005\u01e5\u0000\u0000\u0b14"+ + "\u0b1c\u0003\u01ce\u00e7\u0000\u0b15\u0b16\u0005\f\u0000\u0000\u0b16\u0b1c"+ + "\u0003\u01ce\u00e7\u0000\u0b17\u0b18\u0005\u026d\u0000\u0000\u0b18\u0b1c"+ + "\u0003\u01ce\u00e7\u0000\u0b19\u0b1a\u0005\u0234\u0000\u0000\u0b1a\u0b1c"+ + "\u0005\u0306\u0000\u0000\u0b1b\u0af4\u0001\u0000\u0000\u0000\u0b1b\u0af5"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0af6\u0001\u0000\u0000\u0000\u0b1b\u0af7"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0af8\u0001\u0000\u0000\u0000\u0b1b\u0af9"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0afa\u0001\u0000\u0000\u0000\u0b1b\u0afb"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0afc\u0001\u0000\u0000\u0000\u0b1b\u0afd"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0afe\u0001\u0000\u0000\u0000\u0b1b\u0aff"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0b00\u0001\u0000\u0000\u0000\u0b1b\u0b01"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0b02\u0001\u0000\u0000\u0000\u0b1b\u0b06"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0b0a\u0001\u0000\u0000\u0000\u0b1b\u0b0d"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0b10\u0001\u0000\u0000\u0000\u0b1b\u0b13"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0b15\u0001\u0000\u0000\u0000\u0b1b\u0b17"+ + "\u0001\u0000\u0000\u0000\u0b1b\u0b19\u0001\u0000\u0000\u0000\u0b1c\u0b1d"+ + "\u0001\u0000\u0000\u0000\u0b1d\u0b1b\u0001\u0000\u0000\u0000\u0b1d\u0b1e"+ + "\u0001\u0000\u0000\u0000\u0b1e\u0b20\u0001\u0000\u0000\u0000\u0b1f\u0af2"+ + "\u0001\u0000\u0000\u0000\u0b1f\u0b20\u0001\u0000\u0000\u0000\u0b20\u00a3"+ + "\u0001\u0000\u0000\u0000\u0b21\u0b22\u0007\u000b\u0000\u0000\u0b22\u00a5"+ + "\u0001\u0000\u0000\u0000\u0b23\u0b26\u0005~\u0000\u0000\u0b24\u0b25\u0005"+ + "\u0187\u0000\u0000\u0b25\u0b27\u0005\u01d6\u0000\u0000\u0b26\u0b24\u0001"+ + "\u0000\u0000\u0000\u0b26\u0b27\u0001\u0000\u0000\u0000\u0b27\u0b28\u0001"+ + "\u0000\u0000\u0000\u0b28\u0b29\u0005\u01f0\u0000\u0000\u0b29\u0b2a\u0003"+ + "\u01cc\u00e6\u0000\u0b2a\u0b2b\u0005\u001b\u0000\u0000\u0b2b\u0b2c\u0005"+ + "\u0180\u0000\u0000\u0b2c\u0b2d\u0003\u00a4R\u0000\u0b2d\u0b2e\u0005\u0247"+ + "\u0000\u0000\u0b2e\u0b31\u0003\u0202\u0101\u0000\u0b2f\u0b30\u0005\u0284"+ + "\u0000\u0000\u0b30\u0b32\u0003\u01ec\u00f6\u0000\u0b31\u0b2f\u0001\u0000"+ + "\u0000\u0000\u0b31\u0b32\u0001\u0000\u0000\u0000\u0b32\u0b33\u0001\u0000"+ + "\u0000\u0000\u0b33\u0b35\u0005\u00b9\u0000\u0000\u0b34\u0b36\u0007\f\u0000"+ + "\u0000\u0b35\u0b34\u0001\u0000\u0000\u0000\u0b35\u0b36\u0001\u0000\u0000"+ + "\u0000\u0b36\u0b39\u0001\u0000\u0000\u0000\u0b37\u0b3a\u0005\u016e\u0000"+ + "\u0000\u0b38\u0b3a\u0003\u0202\u0101\u0000\u0b39\u0b37\u0001\u0000\u0000"+ + "\u0000\u0b39\u0b38\u0001\u0000\u0000\u0000\u0b3a\u00a7\u0001\u0000\u0000"+ + "\u0000\u0b3b\u0b3c\u0005~\u0000\u0000\u0b3c\u0b3d\u0005\u01f3\u0000\u0000"+ + "\u0b3d\u0b40\u0003\u0202\u0101\u0000\u0b3e\u0b3f\u0005%\u0000\u0000\u0b3f"+ + "\u0b41\u0003\u01fa\u00fd\u0000\u0b40\u0b3e\u0001\u0000\u0000\u0000\u0b40"+ + "\u0b41\u0001\u0000\u0000\u0000\u0b41\u0b43\u0001\u0000\u0000\u0000\u0b42"+ + "\u0b44\u0003\u0204\u0102\u0000\u0b43\u0b42\u0001\u0000\u0000\u0000\u0b43"+ + "\u0b44\u0001\u0000\u0000\u0000\u0b44\u0b5e\u0001\u0000\u0000\u0000\u0b45"+ + "\u0b46\u0005~\u0000\u0000\u0b46\u0b47\u0005\u01f3\u0000\u0000\u0b47\u0b48"+ + "\u0005%\u0000\u0000\u0b48\u0b4a\u0003\u01fa\u00fd\u0000\u0b49\u0b4b\u0003"+ + "\u0204\u0102\u0000\u0b4a\u0b49\u0001\u0000\u0000\u0000\u0b4a\u0b4b\u0001"+ + "\u0000\u0000\u0000\u0b4b\u0b5e\u0001\u0000\u0000\u0000\u0b4c\u0b4d\u0005"+ + "~\u0000\u0000\u0b4d\u0b4e\u0005\u01f3\u0000\u0000\u0b4e\u0b4f\u0005\u02b3"+ + "\u0000\u0000\u0b4f\u0b50\u0005\u016d\u0000\u0000\u0b50\u0b51\u0005\u00d3"+ + "\u0000\u0000\u0b51\u0b54\u0003\u0202\u0101\u0000\u0b52\u0b53\u0005%\u0000"+ + "\u0000\u0b53\u0b55\u0003\u01fa\u00fd\u0000\u0b54\u0b52\u0001\u0000\u0000"+ + "\u0000\u0b54\u0b55\u0001\u0000\u0000\u0000\u0b55\u0b5e\u0001\u0000\u0000"+ + "\u0000\u0b56\u0b57\u0005~\u0000\u0000\u0b57\u0b58\u0005\u01f3\u0000\u0000"+ + "\u0b58\u0b59\u0005\u02b3\u0000\u0000\u0b59\u0b5a\u0005\u016d\u0000\u0000"+ + "\u0b5a\u0b5b\u0005\u00d3\u0000\u0000\u0b5b\u0b5c\u0005%\u0000\u0000\u0b5c"+ + "\u0b5e\u0003\u01fa\u00fd\u0000\u0b5d\u0b3b\u0001\u0000\u0000\u0000\u0b5d"+ + "\u0b45\u0001\u0000\u0000\u0000\u0b5d\u0b4c\u0001\u0000\u0000\u0000\u0b5d"+ + "\u0b56\u0001\u0000\u0000\u0000\u0b5e\u00a9\u0001\u0000\u0000\u0000\u0b5f"+ + "\u0b61\u0005~\u0000\u0000\u0b60\u0b62\u0007\r\u0000\u0000\u0b61\u0b60"+ + "\u0001\u0000\u0000\u0000\u0b61\u0b62\u0001\u0000\u0000\u0000\u0b62\u0b63"+ + "\u0001\u0000\u0000\u0000\u0b63\u0b67\u0005\u0201\u0000\u0000\u0b64\u0b65"+ + "\u0005\u02b3\u0000\u0000\u0b65\u0b66\u0005\u016d\u0000\u0000\u0b66\u0b68"+ + "\u0005\u00d3\u0000\u0000\u0b67\u0b64\u0001\u0000\u0000\u0000\u0b67\u0b68"+ + "\u0001\u0000\u0000\u0000\u0b68\u0b69\u0001\u0000\u0000\u0000\u0b69\u0b6f"+ + "\u0003\u0202\u0101\u0000\u0b6a\u0b6c\u0005\u010b\u0000\u0000\u0b6b\u0b6d"+ + "\u00056\u0000\u0000\u0b6c\u0b6b\u0001\u0000\u0000\u0000\u0b6c\u0b6d\u0001"+ + "\u0000\u0000\u0000\u0b6d\u0b6e\u0001\u0000\u0000\u0000\u0b6e\u0b70\u0005"+ + "\u0306\u0000\u0000\u0b6f\u0b6a\u0001\u0000\u0000\u0000\u0b6f\u0b70\u0001"+ + "\u0000\u0000\u0000\u0b70\u0b75\u0001\u0000\u0000\u0000\u0b71\u0b72\u0005"+ + "\u0153\u0000\u0000\u0b72\u0b76\u0005\u0306\u0000\u0000\u0b73\u0b74\u0005"+ + "\u0167\u0000\u0000\u0b74\u0b76\u0005\u0153\u0000\u0000\u0b75\u0b71\u0001"+ + "\u0000\u0000\u0000\u0b75\u0b73\u0001\u0000\u0000\u0000\u0b75\u0b76\u0001"+ + "\u0000\u0000\u0000\u0b76\u0b7b\u0001\u0000\u0000\u0000\u0b77\u0b78\u0005"+ + "\u014a\u0000\u0000\u0b78\u0b7c\u0005\u0306\u0000\u0000\u0b79\u0b7a\u0005"+ + "\u0167\u0000\u0000\u0b7a\u0b7c\u0005\u014a\u0000\u0000\u0b7b\u0b77\u0001"+ + "\u0000\u0000\u0000\u0b7b\u0b79\u0001\u0000\u0000\u0000\u0b7b\u0b7c\u0001"+ + "\u0000\u0000\u0000\u0b7c\u0b82\u0001\u0000\u0000\u0000\u0b7d\u0b7f\u0005"+ + "\u0220\u0000\u0000\u0b7e\u0b80\u0005\u0287\u0000\u0000\u0b7f\u0b7e\u0001"+ + "\u0000\u0000\u0000\u0b7f\u0b80\u0001\u0000\u0000\u0000\u0b80\u0b81\u0001"+ + "\u0000\u0000\u0000\u0b81\u0b83\u0005\u0306\u0000\u0000\u0b82\u0b7d\u0001"+ + "\u0000\u0000\u0000\u0b82\u0b83\u0001\u0000\u0000\u0000\u0b83\u0b86\u0001"+ + "\u0000\u0000\u0000\u0b84\u0b85\u00058\u0000\u0000\u0b85\u0b87\u0005\u0306"+ + "\u0000\u0000\u0b86\u0b84\u0001\u0000\u0000\u0000\u0b86\u0b87\u0001\u0000"+ + "\u0000\u0000\u0b87\u0b8c\u0001\u0000\u0000\u0000\u0b88\u0b8a\u0005\u0167"+ + "\u0000\u0000\u0b89\u0b88\u0001\u0000\u0000\u0000\u0b89\u0b8a\u0001\u0000"+ + "\u0000\u0000\u0b8a\u0b8b\u0001\u0000\u0000\u0000\u0b8b\u0b8d\u0005\u0090"+ + "\u0000\u0000\u0b8c\u0b89\u0001\u0000\u0000\u0000\u0b8c\u0b8d\u0001\u0000"+ + "\u0000\u0000\u0b8d\u0b97\u0001\u0000\u0000\u0000\u0b8e\u0b8f\u0005\u02cf"+ + "\u0000\u0000\u0b8f\u0b95\u00056\u0000\u0000\u0b90\u0b91\u0003\u0202\u0101"+ + "\u0000\u0b91\u0b92\u0005\u0308\u0000\u0000\u0b92\u0b93\u0003\u0202\u0101"+ + "\u0000\u0b93\u0b96\u0001\u0000\u0000\u0000\u0b94\u0b96\u0005\u016a\u0000"+ + "\u0000\u0b95\u0b90\u0001\u0000\u0000\u0000\u0b95\u0b94\u0001\u0000\u0000"+ + "\u0000\u0b96\u0b98\u0001\u0000\u0000\u0000\u0b97\u0b8e\u0001\u0000\u0000"+ + "\u0000\u0b97\u0b98\u0001\u0000\u0000\u0000\u0b98\u00ab\u0001\u0000\u0000"+ + "\u0000\u0b99\u0b9a\u0003\u0206\u0103\u0000\u0b9a\u00ad\u0001\u0000\u0000"+ + "\u0000\u0b9b\u0b9c\u0003\u0206\u0103\u0000\u0b9c\u00af\u0001\u0000\u0000"+ + "\u0000\u0b9d\u0b9e\u0003\u0206\u0103\u0000\u0b9e\u00b1\u0001\u0000\u0000"+ + "\u0000\u0b9f\u0ba0\u0003\u0206\u0103\u0000\u0ba0\u00b3\u0001\u0000\u0000"+ + "\u0000\u0ba1\u0ba2\u0003\u0206\u0103\u0000\u0ba2\u00b5\u0001\u0000\u0000"+ + "\u0000\u0ba3\u0ba4\u0003\u0206\u0103\u0000\u0ba4\u00b7\u0001\u0000\u0000"+ + "\u0000\u0ba5\u0ba6\u0003\u0206\u0103\u0000\u0ba6\u00b9\u0001\u0000\u0000"+ + "\u0000\u0ba7\u0ba8\u0003\u0206\u0103\u0000\u0ba8\u00bb\u0001\u0000\u0000"+ + "\u0000\u0ba9\u0baa\u0003\u0206\u0103\u0000\u0baa\u00bd\u0001\u0000\u0000"+ + "\u0000\u0bab\u0bac\u0003\u0206\u0103\u0000\u0bac\u00bf\u0001\u0000\u0000"+ + "\u0000\u0bad\u0bae\u0003\u0206\u0103\u0000\u0bae\u00c1\u0001\u0000\u0000"+ + "\u0000\u0baf\u0bb0\u0003\u0206\u0103\u0000\u0bb0\u00c3\u0001\u0000\u0000"+ + "\u0000\u0bb1\u0bb2\u0003\u0206\u0103\u0000\u0bb2\u00c5\u0001\u0000\u0000"+ + "\u0000\u0bb3\u0bb4\u0003\u0206\u0103\u0000\u0bb4\u00c7\u0001\u0000\u0000"+ + "\u0000\u0bb5\u0bb6\u0003\u0206\u0103\u0000\u0bb6\u00c9\u0001\u0000\u0000"+ + "\u0000\u0bb7\u0bba\u0005~\u0000\u0000\u0bb8\u0bb9\u0005\u0187\u0000\u0000"+ + "\u0bb9\u0bbb\u0005\u01d6\u0000\u0000\u0bba\u0bb8\u0001\u0000\u0000\u0000"+ + "\u0bba\u0bbb\u0001\u0000\u0000\u0000\u0bbb\u0bbd\u0001\u0000\u0000\u0000"+ + "\u0bbc\u0bbe\u0007\r\u0000\u0000\u0bbd\u0bbc\u0001\u0000\u0000\u0000\u0bbd"+ + "\u0bbe\u0001\u0000\u0000\u0000\u0bbe\u0bc0\u0001\u0000\u0000\u0000\u0bbf"+ + "\u0bc1\u0005\u01c3\u0000\u0000\u0bc0\u0bbf\u0001\u0000\u0000\u0000\u0bc0"+ + "\u0bc1\u0001\u0000\u0000\u0000\u0bc1\u0bc2\u0001\u0000\u0000\u0000\u0bc2"+ + "\u0bc3\u0005\u0280\u0000\u0000\u0bc3\u0bc8\u0003\u01cc\u00e6\u0000\u0bc4"+ + "\u0bc5\u0005\u02ff\u0000\u0000\u0bc5\u0bc6\u0003\u01ce\u00e7\u0000\u0bc6"+ + "\u0bc7\u0005\u0300\u0000\u0000\u0bc7\u0bc9\u0001\u0000\u0000\u0000\u0bc8"+ + "\u0bc4\u0001\u0000\u0000\u0000\u0bc8\u0bc9\u0001\u0000\u0000\u0000\u0bc9"+ + "\u0bcf\u0001\u0000\u0000\u0000\u0bca\u0bcb\u0005\u0287\u0000\u0000\u0bcb"+ + "\u0bcc\u0005\u02ff\u0000\u0000\u0bcc\u0bcd\u0003\u01d4\u00ea\u0000\u0bcd"+ + "\u0bce\u0005\u0300\u0000\u0000\u0bce\u0bd0\u0001\u0000\u0000\u0000\u0bcf"+ + "\u0bca\u0001\u0000\u0000\u0000\u0bcf\u0bd0\u0001\u0000\u0000\u0000\u0bd0"+ + "\u0bd1\u0001\u0000\u0000\u0000\u0bd1\u0bd4\u0005\u001b\u0000\u0000\u0bd2"+ + "\u0bd5\u0003\u0158\u00ac\u0000\u0bd3\u0bd5\u0003\u017c\u00be\u0000\u0bd4"+ + "\u0bd2\u0001\u0000\u0000\u0000\u0bd4\u0bd3\u0001\u0000\u0000\u0000\u0bd5"+ + "\u0bdc\u0001\u0000\u0000\u0000\u0bd6\u0bd8\u0005\u0287\u0000\u0000\u0bd7"+ + "\u0bd9\u0007\u000e\u0000\u0000\u0bd8\u0bd7\u0001\u0000\u0000\u0000\u0bd8"+ + "\u0bd9\u0001\u0000\u0000\u0000\u0bd9\u0bda\u0001\u0000\u0000\u0000\u0bda"+ + "\u0bdb\u0005N\u0000\u0000\u0bdb\u0bdd\u0005\u0185\u0000\u0000\u0bdc\u0bd6"+ + "\u0001\u0000\u0000\u0000\u0bdc\u0bdd\u0001\u0000\u0000\u0000\u0bdd\u00cb"+ + "\u0001\u0000\u0000\u0000\u0bde\u0bdf\u0003\u0206\u0103\u0000\u0bdf\u00cd"+ + "\u0001\u0000\u0000\u0000\u0be0\u0be1\u0003\u0206\u0103\u0000\u0be1\u00cf"+ + "\u0001\u0000\u0000\u0000\u0be2\u0be4\u0003\u015c\u00ae\u0000\u0be3\u0be2"+ + "\u0001\u0000\u0000\u0000\u0be3\u0be4\u0001\u0000\u0000\u0000\u0be4\u0be5"+ + "\u0001\u0000\u0000\u0000\u0be5\u0be6\u0005\u00a3\u0000\u0000\u0be6\u0be8"+ + "\u0005\u00ec\u0000\u0000\u0be7\u0be9\u0005\u0181\u0000\u0000\u0be8\u0be7"+ + "\u0001\u0000\u0000\u0000\u0be8\u0be9\u0001\u0000\u0000\u0000\u0be9\u0bea"+ + "\u0001\u0000\u0000\u0000\u0bea\u0bec\u0003\u01d6\u00eb\u0000\u0beb\u0bed"+ + "\u0005\u02fe\u0000\u0000\u0bec\u0beb\u0001\u0000\u0000\u0000\u0bec\u0bed"+ + "\u0001\u0000\u0000\u0000\u0bed\u0bf2\u0001\u0000\u0000\u0000\u0bee\u0bf0"+ + "\u0005\u001b\u0000\u0000\u0bef\u0bee\u0001\u0000\u0000\u0000\u0bef\u0bf0"+ + "\u0001\u0000\u0000\u0000\u0bf0\u0bf1\u0001\u0000\u0000\u0000\u0bf1\u0bf3"+ + "\u0003\u020c\u0106\u0000\u0bf2\u0bef\u0001\u0000\u0000\u0000\u0bf2\u0bf3"+ + "\u0001\u0000\u0000\u0000\u0bf3\u0bf6\u0001\u0000\u0000\u0000\u0bf4\u0bf5"+ + "\u0005\u0272\u0000\u0000\u0bf5\u0bf7\u0003\u01d0\u00e8\u0000\u0bf6\u0bf4"+ + "\u0001\u0000\u0000\u0000\u0bf6\u0bf7\u0001\u0000\u0000\u0000\u0bf7\u0bfd"+ + "\u0001\u0000\u0000\u0000\u0bf8\u0bfe\u0003\u0182\u00c1\u0000\u0bf9\u0bfa"+ + "\u0005\u0284\u0000\u0000\u0bfa\u0bfb\u0005\u0085\u0000\u0000\u0bfb\u0bfc"+ + "\u0005\u017b\u0000\u0000\u0bfc\u0bfe\u0003\u0202\u0101\u0000\u0bfd\u0bf8"+ + "\u0001\u0000\u0000\u0000\u0bfd\u0bf9\u0001\u0000\u0000\u0000\u0bfd\u0bfe"+ + "\u0001\u0000\u0000\u0000\u0bfe\u0c00\u0001\u0000\u0000\u0000\u0bff\u0c01"+ + "\u0003\u01ae\u00d7\u0000\u0c00\u0bff\u0001\u0000\u0000\u0000\u0c00\u0c01"+ + "\u0001\u0000\u0000\u0000\u0c01\u00d1\u0001\u0000\u0000\u0000\u0c02\u0c03"+ + "\u0005\u00b5\u0000\u0000\u0c03\u0c04\u0007\u000f\u0000\u0000\u0c04\u00d3"+ + "\u0001\u0000\u0000\u0000\u0c05\u0c2f\u0003\u00d6k\u0000\u0c06\u0c2f\u0003"+ + "\u00d8l\u0000\u0c07\u0c2f\u0003\u00dam\u0000\u0c08\u0c2f\u0003\u00dcn"+ + "\u0000\u0c09\u0c2f\u0003\u00deo\u0000\u0c0a\u0c2f\u0003\u00e0p\u0000\u0c0b"+ + "\u0c2f\u0003\u00e2q\u0000\u0c0c\u0c2f\u0003\u00e4r\u0000\u0c0d\u0c2f\u0003"+ + "\u00e6s\u0000\u0c0e\u0c2f\u0003\u00e8t\u0000\u0c0f\u0c2f\u0003\u00eau"+ + "\u0000\u0c10\u0c2f\u0003\u00ecv\u0000\u0c11\u0c2f\u0003\u00eew\u0000\u0c12"+ + "\u0c2f\u0003\u00f0x\u0000\u0c13\u0c2f\u0003\u00f2y\u0000\u0c14\u0c2f\u0003"+ + "\u00f4z\u0000\u0c15\u0c2f\u0003\u00f6{\u0000\u0c16\u0c2f\u0003\u00f8|"+ + "\u0000\u0c17\u0c2f\u0003\u00fa}\u0000\u0c18\u0c2f\u0003\u00fc~\u0000\u0c19"+ + "\u0c2f\u0003\u00fe\u007f\u0000\u0c1a\u0c2f\u0003\u0100\u0080\u0000\u0c1b"+ + "\u0c2f\u0003\u0102\u0081\u0000\u0c1c\u0c2f\u0003\u0104\u0082\u0000\u0c1d"+ + "\u0c2f\u0003\u0106\u0083\u0000\u0c1e\u0c2f\u0003\u0108\u0084\u0000\u0c1f"+ + "\u0c2f\u0003\u010a\u0085\u0000\u0c20\u0c2f\u0003\u010c\u0086\u0000\u0c21"+ + "\u0c2f\u0003\u010e\u0087\u0000\u0c22\u0c2f\u0003\u0110\u0088\u0000\u0c23"+ + "\u0c2f\u0003\u0112\u0089\u0000\u0c24\u0c2f\u0003\u0114\u008a\u0000\u0c25"+ + "\u0c2f\u0003\u0116\u008b\u0000\u0c26\u0c2f\u0003\u0118\u008c\u0000\u0c27"+ + "\u0c2f\u0003\u011a\u008d\u0000\u0c28\u0c2f\u0003\u011c\u008e\u0000\u0c29"+ + "\u0c2f\u0003\u011e\u008f\u0000\u0c2a\u0c2f\u0003\u0120\u0090\u0000\u0c2b"+ + "\u0c2f\u0003\u0122\u0091\u0000\u0c2c\u0c2f\u0003\u0124\u0092\u0000\u0c2d"+ + "\u0c2f\u0003\u0126\u0093\u0000\u0c2e\u0c05\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c06\u0001\u0000\u0000\u0000\u0c2e\u0c07\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c08\u0001\u0000\u0000\u0000\u0c2e\u0c09\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c0a\u0001\u0000\u0000\u0000\u0c2e\u0c0b\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c0c\u0001\u0000\u0000\u0000\u0c2e\u0c0d\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c0e\u0001\u0000\u0000\u0000\u0c2e\u0c0f\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c10\u0001\u0000\u0000\u0000\u0c2e\u0c11\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c12\u0001\u0000\u0000\u0000\u0c2e\u0c13\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c14\u0001\u0000\u0000\u0000\u0c2e\u0c15\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c16\u0001\u0000\u0000\u0000\u0c2e\u0c17\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c18\u0001\u0000\u0000\u0000\u0c2e\u0c19\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c1a\u0001\u0000\u0000\u0000\u0c2e\u0c1b\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c1c\u0001\u0000\u0000\u0000\u0c2e\u0c1d\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c1e\u0001\u0000\u0000\u0000\u0c2e\u0c1f\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c20\u0001\u0000\u0000\u0000\u0c2e\u0c21\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c22\u0001\u0000\u0000\u0000\u0c2e\u0c23\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c24\u0001\u0000\u0000\u0000\u0c2e\u0c25\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c26\u0001\u0000\u0000\u0000\u0c2e\u0c27\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c28\u0001\u0000\u0000\u0000\u0c2e\u0c29\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c2a\u0001\u0000\u0000\u0000\u0c2e\u0c2b\u0001\u0000\u0000\u0000\u0c2e"+ + "\u0c2c\u0001\u0000\u0000\u0000\u0c2e\u0c2d\u0001\u0000\u0000\u0000\u0c2f"+ + "\u00d5\u0001\u0000\u0000\u0000\u0c30\u0c31\u0005\u00bc\u0000\u0000\u0c31"+ + "\u0c32\u0005\b\u0000\u0000\u0c32\u0c35\u0005\u0150\u0000\u0000\u0c33\u0c34"+ + "\u0005\u02b3\u0000\u0000\u0c34\u0c36\u0005\u00d3\u0000\u0000\u0c35\u0c33"+ + "\u0001\u0000\u0000\u0000\u0c35\u0c36\u0001\u0000\u0000\u0000\u0c36\u0c37"+ + "\u0001\u0000\u0000\u0000\u0c37\u0c39\u0003\u0202\u0101\u0000\u0c38\u0c3a"+ + "\u0007\u0001\u0000\u0000\u0c39\u0c38\u0001\u0000\u0000\u0000\u0c39\u0c3a"+ + "\u0001\u0000\u0000\u0000\u0c3a\u00d7\u0001\u0000\u0000\u0000\u0c3b\u0c3c"+ + "\u0005\u00bc\u0000\u0000\u0c3c\u0c3f\u0005\u000e\u0000\u0000\u0c3d\u0c3e"+ + "\u0005\u02b3\u0000\u0000\u0c3e\u0c40\u0005\u00d3\u0000\u0000\u0c3f\u0c3d"+ + "\u0001\u0000\u0000\u0000\u0c3f\u0c40\u0001\u0000\u0000\u0000\u0c40\u0c41"+ + "\u0001\u0000\u0000\u0000\u0c41\u0c42\u0003\u0202\u0101\u0000\u0c42\u0c43"+ + "\u0005\u02ff\u0000\u0000\u0c43\u0c44\u0003\u01ee\u00f7\u0000\u0c44\u0c45"+ + "\u0005\u0300\u0000\u0000\u0c45\u00d9\u0001\u0000\u0000\u0000\u0c46\u0c47"+ + "\u0005\u00bc\u0000\u0000\u0c47\u0c4a\u0005?\u0000\u0000\u0c48\u0c49\u0005"+ + "\u02b3\u0000\u0000\u0c49\u0c4b\u0005\u00d3\u0000\u0000\u0c4a\u0c48\u0001"+ + "\u0000\u0000\u0000\u0c4a\u0c4b\u0001\u0000\u0000\u0000\u0c4b\u0c4c\u0001"+ + "\u0000\u0000\u0000\u0c4c\u0c4d\u0005\u02ff\u0000\u0000\u0c4d\u0c4e\u0003"+ + "\u01d8\u00ec\u0000\u0c4e\u0c4f\u0005\u001b\u0000\u0000\u0c4f\u0c50\u0003"+ + "\u0202\u0101\u0000\u0c50\u0c52\u0005\u0300\u0000\u0000\u0c51\u0c53\u0007"+ + "\u0001\u0000\u0000\u0c52\u0c51\u0001\u0000\u0000\u0000\u0c52\u0c53\u0001"+ + "\u0000\u0000\u0000\u0c53\u00db\u0001\u0000\u0000\u0000\u0c54\u0c55\u0005"+ + "\u00bc\u0000\u0000\u0c55\u0c58\u0005Y\u0000\u0000\u0c56\u0c57\u0005\u02b3"+ + "\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\u0c5c\u0003\u01d0\u00e8\u0000\u0c5b\u0c5d\u0007\u0001"+ + "\u0000\u0000\u0c5c\u0c5b\u0001\u0000\u0000\u0000\u0c5c\u0c5d\u0001\u0000"+ + "\u0000\u0000\u0c5d\u00dd\u0001\u0000\u0000\u0000\u0c5e\u0c5f\u0005\u00bc"+ + "\u0000\u0000\u0c5f\u0c62\u0005u\u0000\u0000\u0c60\u0c61\u0005\u02b3\u0000"+ + "\u0000\u0c61\u0c63\u0005\u00d3\u0000\u0000\u0c62\u0c60\u0001\u0000\u0000"+ + "\u0000\u0c62\u0c63\u0001\u0000\u0000\u0000\u0c63\u0c64\u0001\u0000\u0000"+ + "\u0000\u0c64\u0c66\u0003\u0202\u0101\u0000\u0c65\u0c67\u0007\u0001\u0000"+ + "\u0000\u0c66\u0c65\u0001\u0000\u0000\u0000\u0c66\u0c67\u0001\u0000\u0000"+ + "\u0000\u0c67\u00df\u0001\u0000\u0000\u0000\u0c68\u0c69\u0005\u00bc\u0000"+ + "\u0000\u0c69\u0c6c\u0005\u0092\u0000\u0000\u0c6a\u0c6b\u0005\u02b3\u0000"+ + "\u0000\u0c6b\u0c6d\u0005\u00d3\u0000\u0000\u0c6c\u0c6a\u0001\u0000\u0000"+ + "\u0000\u0c6c\u0c6d\u0001\u0000\u0000\u0000\u0c6d\u0c6e\u0001\u0000\u0000"+ + "\u0000\u0c6e\u0c6f\u0003\u0202\u0101\u0000\u0c6f\u00e1\u0001\u0000\u0000"+ + "\u0000\u0c70\u0c71\u0005\u00bc\u0000\u0000\u0c71\u0c74\u0005\u00ba\u0000"+ + "\u0000\u0c72\u0c73\u0005\u02b3\u0000\u0000\u0c73\u0c75\u0005\u00d3\u0000"+ + "\u0000\u0c74\u0c72\u0001\u0000\u0000\u0000\u0c74\u0c75\u0001\u0000\u0000"+ + "\u0000\u0c75\u0c76\u0001\u0000\u0000\u0000\u0c76\u0c78\u0003\u01d0\u00e8"+ + "\u0000\u0c77\u0c79\u0007\u0001\u0000\u0000\u0c78\u0c77\u0001\u0000\u0000"+ + "\u0000\u0c78\u0c79\u0001\u0000\u0000\u0000\u0c79\u00e3\u0001\u0000\u0000"+ + "\u0000\u0c7a\u0c7b\u0005\u00bc\u0000\u0000\u0c7b\u0c7c\u0005\u02bb\u0000"+ + "\u0000\u0c7c\u0c7f\u0005\u0254\u0000\u0000\u0c7d\u0c7e\u0005\u02b3\u0000"+ + "\u0000\u0c7e\u0c80\u0005\u00d3\u0000\u0000\u0c7f\u0c7d\u0001\u0000\u0000"+ + "\u0000\u0c7f\u0c80\u0001\u0000\u0000\u0000\u0c80\u0c81\u0001\u0000\u0000"+ + "\u0000\u0c81\u0c83\u0003\u0202\u0101\u0000\u0c82\u0c84\u0007\u0001\u0000"+ + "\u0000\u0c83\u0c82\u0001\u0000\u0000\u0000\u0c83\u0c84\u0001\u0000\u0000"+ + "\u0000\u0c84\u00e5\u0001\u0000\u0000\u0000\u0c85\u0c86\u0005\u00bc\u0000"+ + "\u0000\u0c86\u0c89\u0005\u00d7\u0000\u0000\u0c87\u0c88\u0005\u02b3\u0000"+ + "\u0000\u0c88\u0c8a\u0005\u00d3\u0000\u0000\u0c89\u0c87\u0001\u0000\u0000"+ + "\u0000\u0c89\u0c8a\u0001\u0000\u0000\u0000\u0c8a\u0c8b\u0001\u0000\u0000"+ + "\u0000\u0c8b\u0c8d\u0003\u01d0\u00e8\u0000\u0c8c\u0c8e\u0007\u0001\u0000"+ + "\u0000\u0c8d\u0c8c\u0001\u0000\u0000\u0000\u0c8d\u0c8e\u0001\u0000\u0000"+ + "\u0000\u0c8e\u00e7\u0001\u0000\u0000\u0000\u0c8f\u0c90\u0005\u00bc\u0000"+ + "\u0000\u0c90\u0c91\u0005\u00e5\u0000\u0000\u0c91\u0c92\u0005\u0091\u0000"+ + "\u0000\u0c92\u0c95\u0005\u02bc\u0000\u0000\u0c93\u0c94\u0005\u02b3\u0000"+ + "\u0000\u0c94\u0c96\u0005\u00d3\u0000\u0000\u0c95\u0c93\u0001\u0000\u0000"+ + "\u0000\u0c95\u0c96\u0001\u0000\u0000\u0000\u0c96\u0c97\u0001\u0000\u0000"+ + "\u0000\u0c97\u0c99\u0003\u01d0\u00e8\u0000\u0c98\u0c9a\u0007\u0001\u0000"+ + "\u0000\u0c99\u0c98\u0001\u0000\u0000\u0000\u0c99\u0c9a\u0001\u0000\u0000"+ + "\u0000\u0c9a\u00e9\u0001\u0000\u0000\u0000\u0c9b\u0c9c\u0005\u00bc\u0000"+ + "\u0000\u0c9c\u0c9d\u0005\u00e5\u0000\u0000\u0c9d\u0ca0\u0005\u0237\u0000"+ + "\u0000\u0c9e\u0c9f\u0005\u02b3\u0000\u0000\u0c9f\u0ca1\u0005\u00d3\u0000"+ + "\u0000\u0ca0\u0c9e\u0001\u0000\u0000\u0000\u0ca0\u0ca1\u0001\u0000\u0000"+ + "\u0000\u0ca1\u0ca2\u0001\u0000\u0000\u0000\u0ca2\u0ca4\u0003\u01d0\u00e8"+ + "\u0000\u0ca3\u0ca5\u0007\u0001\u0000\u0000\u0ca4\u0ca3\u0001\u0000\u0000"+ + "\u0000\u0ca4\u0ca5\u0001\u0000\u0000\u0000\u0ca5\u00eb\u0001\u0000\u0000"+ + "\u0000\u0ca6\u0ca7\u0005\u00bc\u0000\u0000\u0ca7\u0caa\u0005\u00ee\u0000"+ + "\u0000\u0ca8\u0ca9\u0005\u02b3\u0000\u0000\u0ca9\u0cab\u0005\u00d3\u0000"+ + "\u0000\u0caa\u0ca8\u0001\u0000\u0000\u0000\u0caa\u0cab\u0001\u0000\u0000"+ + "\u0000\u0cab\u0cac\u0001\u0000\u0000\u0000\u0cac\u0cae\u0003\u01c2\u00e1"+ + "\u0000\u0cad\u0caf\u0007\u0001\u0000\u0000\u0cae\u0cad\u0001\u0000\u0000"+ + "\u0000\u0cae\u0caf\u0001\u0000\u0000\u0000\u0caf\u00ed\u0001\u0000\u0000"+ + "\u0000\u0cb0\u0cb1\u0005\u00bc\u0000\u0000\u0cb1\u0cb4\u0005\u00fa\u0000"+ + "\u0000\u0cb2\u0cb3\u0005\u02b3\u0000\u0000\u0cb3\u0cb5\u0005\u00d3\u0000"+ + "\u0000\u0cb4\u0cb2\u0001\u0000\u0000\u0000\u0cb4\u0cb5\u0001\u0000\u0000"+ + "\u0000\u0cb5\u0cb6\u0001\u0000\u0000\u0000\u0cb6\u0cb7\u0003\u01d0\u00e8"+ + "\u0000\u0cb7\u00ef\u0001\u0000\u0000\u0000\u0cb8\u0cb9\u0005\u00bc\u0000"+ + "\u0000\u0cb9\u0cbb\u0005\u010c\u0000\u0000\u0cba\u0cbc\u0005\u02c4\u0000"+ + "\u0000\u0cbb\u0cba\u0001\u0000\u0000\u0000\u0cbb\u0cbc\u0001\u0000\u0000"+ + "\u0000\u0cbc\u0cbf\u0001\u0000\u0000\u0000\u0cbd\u0cbe\u0005\u02b3\u0000"+ + "\u0000\u0cbe\u0cc0\u0005\u00d3\u0000\u0000\u0cbf\u0cbd\u0001\u0000\u0000"+ + "\u0000\u0cbf\u0cc0\u0001\u0000\u0000\u0000\u0cc0\u0cc1\u0001\u0000\u0000"+ + "\u0000\u0cc1\u0cc3\u0003\u01ce\u00e7\u0000\u0cc2\u0cc4\u0007\u0001\u0000"+ + "\u0000\u0cc3\u0cc2\u0001\u0000\u0000\u0000\u0cc3\u0cc4\u0001\u0000\u0000"+ + "\u0000\u0cc4\u00f1\u0001\u0000\u0000\u0000\u0cc5\u0cc7\u0005\u00bc\u0000"+ + "\u0000\u0cc6\u0cc8\u0005\u01b7\u0000\u0000\u0cc7\u0cc6\u0001\u0000\u0000"+ + "\u0000\u0cc7\u0cc8\u0001\u0000\u0000\u0000\u0cc8\u0cc9\u0001\u0000\u0000"+ + "\u0000\u0cc9\u0ccc\u0005\u012b\u0000\u0000\u0cca\u0ccb\u0005\u02b3\u0000"+ + "\u0000\u0ccb\u0ccd\u0005\u00d3\u0000\u0000\u0ccc\u0cca\u0001\u0000\u0000"+ + "\u0000\u0ccc\u0ccd\u0001\u0000\u0000\u0000\u0ccd\u0cce\u0001\u0000\u0000"+ + "\u0000\u0cce\u0cd0\u0003\u0202\u0101\u0000\u0ccf\u0cd1\u0007\u0001\u0000"+ + "\u0000\u0cd0\u0ccf\u0001\u0000\u0000\u0000\u0cd0\u0cd1\u0001\u0000\u0000"+ + "\u0000\u0cd1\u00f3\u0001\u0000\u0000\u0000\u0cd2\u0cd3\u0005\u00bc\u0000"+ + "\u0000\u0cd3\u0cd4\u0005\u02c6\u0000\u0000\u0cd4\u0cd7\u0005\u0280\u0000"+ + "\u0000\u0cd5\u0cd6\u0005\u02b3\u0000\u0000\u0cd6\u0cd8\u0005\u00d3\u0000"+ + "\u0000\u0cd7\u0cd5\u0001\u0000\u0000\u0000\u0cd7\u0cd8\u0001\u0000\u0000"+ + "\u0000\u0cd8\u0cd9\u0001\u0000\u0000\u0000\u0cd9\u0cdb\u0003\u01d0\u00e8"+ + "\u0000\u0cda\u0cdc\u0007\u0001\u0000\u0000\u0cdb\u0cda\u0001\u0000\u0000"+ + "\u0000\u0cdb\u0cdc\u0001\u0000\u0000\u0000\u0cdc\u00f5\u0001\u0000\u0000"+ + "\u0000\u0cdd\u0cde\u0003\u0206\u0103\u0000\u0cde\u00f7\u0001\u0000\u0000"+ + "\u0000\u0cdf\u0ce0\u0005\u00bc\u0000\u0000\u0ce0\u0ce1\u0005\u0184\u0000"+ + "\u0000\u0ce1\u0ce4\u0005Q\u0000\u0000\u0ce2\u0ce3\u0005\u02b3\u0000\u0000"+ + "\u0ce3\u0ce5\u0005\u00d3\u0000\u0000\u0ce4\u0ce2\u0001\u0000\u0000\u0000"+ + "\u0ce4\u0ce5\u0001\u0000\u0000\u0000\u0ce5\u0ce6\u0001\u0000\u0000\u0000"+ + "\u0ce6\u0ce7\u0003\u0202\u0101\u0000\u0ce7\u0ce8\u0005\u0272\u0000\u0000"+ + "\u0ce8\u0cea\u0003\u01dc\u00ee\u0000\u0ce9\u0ceb\u0007\u0001\u0000\u0000"+ + "\u0cea\u0ce9\u0001\u0000\u0000\u0000\u0cea\u0ceb\u0001\u0000\u0000\u0000"+ + "\u0ceb\u00f9\u0001\u0000\u0000\u0000\u0cec\u0ced\u0005\u00bc\u0000\u0000"+ + "\u0ced\u0cee\u0005\u0184\u0000\u0000\u0cee\u0cf1\u0005\u02cd\u0000\u0000"+ + "\u0cef\u0cf0\u0005\u02b3\u0000\u0000\u0cf0\u0cf2\u0005\u00d3\u0000\u0000"+ + "\u0cf1\u0cef\u0001\u0000\u0000\u0000\u0cf1\u0cf2\u0001\u0000\u0000\u0000"+ + "\u0cf2\u0cf3\u0001\u0000\u0000\u0000\u0cf3\u0cf4\u0003\u0202\u0101\u0000"+ + "\u0cf4\u0cf5\u0005\u0272\u0000\u0000\u0cf5\u0cf7\u0003\u01dc\u00ee\u0000"+ + "\u0cf6\u0cf8\u0007\u0001\u0000\u0000\u0cf7\u0cf6\u0001\u0000\u0000\u0000"+ + "\u0cf7\u0cf8\u0001\u0000\u0000\u0000\u0cf8\u00fb\u0001\u0000\u0000\u0000"+ + "\u0cf9\u0cfa\u0005\u00bc\u0000\u0000\u0cfa\u0cfb\u0005\u02cf\u0000\u0000"+ + "\u0cfb\u0cfc\u00056\u0000\u0000\u0cfc\u0cfe\u0003\u01fc\u00fe\u0000\u0cfd"+ + "\u0cff\u0007\u0001\u0000\u0000\u0cfe\u0cfd\u0001\u0000\u0000\u0000\u0cfe"+ + "\u0cff\u0001\u0000\u0000\u0000\u0cff\u00fd\u0001\u0000\u0000\u0000\u0d00"+ + "\u0d01\u0005\u00bc\u0000\u0000\u0d01\u0d04\u0005\u02ce\u0000\u0000\u0d02"+ + "\u0d03\u0005\u02b3\u0000\u0000\u0d03\u0d05\u0005\u00d3\u0000\u0000\u0d04"+ + "\u0d02\u0001\u0000\u0000\u0000\u0d04\u0d05\u0001\u0000\u0000\u0000\u0d05"+ + "\u0d06\u0001\u0000\u0000\u0000\u0d06\u0d07\u0003\u0202\u0101\u0000\u0d07"+ + "\u0d08\u0005\u0180\u0000\u0000\u0d08\u0d0a\u0003\u0202\u0101\u0000\u0d09"+ + "\u0d0b\u0007\u0001\u0000\u0000\u0d0a\u0d09\u0001\u0000\u0000\u0000\u0d0a"+ + "\u0d0b\u0001\u0000\u0000\u0000\u0d0b\u00ff\u0001\u0000\u0000\u0000\u0d0c"+ + "\u0d0d\u0005\u00bc\u0000\u0000\u0d0d\u0d10\u0005\u01ba\u0000\u0000\u0d0e"+ + "\u0d0f\u0005\u02b3\u0000\u0000\u0d0f\u0d11\u0005\u00d3\u0000\u0000\u0d10"+ + "\u0d0e\u0001\u0000\u0000\u0000\u0d10\u0d11\u0001\u0000\u0000\u0000\u0d11"+ + "\u0d12\u0001\u0000\u0000\u0000\u0d12\u0d14\u0003\u01d0\u00e8\u0000\u0d13"+ + "\u0d15\u0007\u0001\u0000\u0000\u0d14\u0d13\u0001\u0000\u0000\u0000\u0d14"+ + "\u0d15\u0001\u0000\u0000\u0000\u0d15\u0101\u0001\u0000\u0000\u0000\u0d16"+ + "\u0d17\u0005\u00bc\u0000\u0000\u0d17\u0d1a\u0005\u01e5\u0000\u0000\u0d18"+ + "\u0d19\u0005\u02b3\u0000\u0000\u0d19\u0d1b\u0005\u00d3\u0000\u0000\u0d1a"+ + "\u0d18\u0001\u0000\u0000\u0000\u0d1a\u0d1b\u0001\u0000\u0000\u0000\u0d1b"+ + "\u0d1c\u0001\u0000\u0000\u0000\u0d1c\u0d1d\u0003\u01d0\u00e8\u0000\u0d1d"+ + "\u0103\u0001\u0000\u0000\u0000\u0d1e\u0d1f\u0005\u00bc\u0000\u0000\u0d1f"+ + "\u0d22\u0005\u01f0\u0000\u0000\u0d20\u0d21\u0005\u02b3\u0000\u0000\u0d21"+ + "\u0d23\u0005\u00d3\u0000\u0000\u0d22\u0d20\u0001\u0000\u0000\u0000\u0d22"+ + "\u0d23\u0001\u0000\u0000\u0000\u0d23\u0d24\u0001\u0000\u0000\u0000\u0d24"+ + "\u0d25\u0003\u01cc\u00e6\u0000\u0d25\u0d26\u0005\u0180\u0000\u0000\u0d26"+ + "\u0d28\u0003\u0202\u0101\u0000\u0d27\u0d29\u0007\u0001\u0000\u0000\u0d28"+ + "\u0d27\u0001\u0000\u0000\u0000\u0d28\u0d29\u0001\u0000\u0000\u0000\u0d29"+ + "\u0105\u0001\u0000\u0000\u0000\u0d2a\u0d2b\u0005\u00bc\u0000\u0000\u0d2b"+ + "\u0d2e\u0005\u01f3\u0000\u0000\u0d2c\u0d2d\u0005\u02b3\u0000\u0000\u0d2d"+ + "\u0d2f\u0005\u00d3\u0000\u0000\u0d2e\u0d2c\u0001\u0000\u0000\u0000\u0d2e"+ + "\u0d2f\u0001\u0000\u0000\u0000\u0d2f\u0d30\u0001\u0000\u0000\u0000\u0d30"+ + "\u0d32\u0003\u01d0\u00e8\u0000\u0d31\u0d33\u0007\u0001\u0000\u0000\u0d32"+ + "\u0d31\u0001\u0000\u0000\u0000\u0d32\u0d33\u0001\u0000\u0000\u0000\u0d33"+ + "\u0107\u0001\u0000\u0000\u0000\u0d34\u0d35\u0005\u00bc\u0000\u0000\u0d35"+ + "\u0d38\u0005\u0201\u0000\u0000\u0d36\u0d37\u0005\u02b3\u0000\u0000\u0d37"+ + "\u0d39\u0005\u00d3\u0000\u0000\u0d38\u0d36\u0001\u0000\u0000\u0000\u0d38"+ + "\u0d39\u0001\u0000\u0000\u0000\u0d39\u0d3a\u0001\u0000\u0000\u0000\u0d3a"+ + "\u0d3c\u0003\u01d0\u00e8\u0000\u0d3b\u0d3d\u0007\u0001\u0000\u0000\u0d3c"+ + "\u0d3b\u0001\u0000\u0000\u0000\u0d3c\u0d3d\u0001\u0000\u0000\u0000\u0d3d"+ + "\u0109\u0001\u0000\u0000\u0000\u0d3e\u0d3f\u0005\u00bc\u0000\u0000\u0d3f"+ + "\u0d42\u0005\u02bd\u0000\u0000\u0d40\u0d41\u0005\u02b3\u0000\u0000\u0d41"+ + "\u0d43\u0005\u00d3\u0000\u0000\u0d42\u0d40\u0001\u0000\u0000\u0000\u0d42"+ + "\u0d43\u0001\u0000\u0000\u0000\u0d43\u0d44\u0001\u0000\u0000\u0000\u0d44"+ + "\u0d46\u0003\u01d0\u00e8\u0000\u0d45\u0d47\u0007\u0001\u0000\u0000\u0d46"+ + "\u0d45\u0001\u0000\u0000\u0000\u0d46\u0d47\u0001\u0000\u0000\u0000\u0d47"+ + "\u010b\u0001\u0000\u0000\u0000\u0d48\u0d49\u0005\u00bc\u0000\u0000\u0d49"+ + "\u0d4c\u0005\u0224\u0000\u0000\u0d4a\u0d4b\u0005\u02b3\u0000\u0000\u0d4b"+ + "\u0d4d\u0005\u00d3\u0000\u0000\u0d4c\u0d4a\u0001\u0000\u0000\u0000\u0d4c"+ + "\u0d4d\u0001\u0000\u0000\u0000\u0d4d\u0d4e\u0001\u0000\u0000\u0000\u0d4e"+ + "\u0d4f\u0003\u01d0\u00e8\u0000\u0d4f\u010d\u0001\u0000\u0000\u0000\u0d50"+ + "\u0d51\u0005\u00bc\u0000\u0000\u0d51\u0d54\u0005\u0230\u0000\u0000\u0d52"+ + "\u0d53\u0005\u02b3\u0000\u0000\u0d53\u0d55\u0005\u00d3\u0000\u0000\u0d54"+ + "\u0d52\u0001\u0000\u0000\u0000\u0d54\u0d55\u0001\u0000\u0000\u0000\u0d55"+ + "\u0d56\u0001\u0000\u0000\u0000\u0d56\u0d58\u0003\u0202\u0101\u0000\u0d57"+ + "\u0d59\u0007\u0001\u0000\u0000\u0d58\u0d57\u0001\u0000\u0000\u0000\u0d58"+ + "\u0d59\u0001\u0000\u0000\u0000\u0d59\u010f\u0001\u0000\u0000\u0000\u0d5a"+ + "\u0d5b\u0005\u00bc\u0000\u0000\u0d5b\u0d5e\u0005\u0237\u0000\u0000\u0d5c"+ + "\u0d5d\u0005\u02b3\u0000\u0000\u0d5d\u0d5f\u0005\u00d3\u0000\u0000\u0d5e"+ + "\u0d5c\u0001\u0000\u0000\u0000\u0d5e\u0d5f\u0001\u0000\u0000\u0000\u0d5f"+ + "\u0d60\u0001\u0000\u0000\u0000\u0d60\u0d62\u0003\u01d0\u00e8\u0000\u0d61"+ + "\u0d63\u0007\u0001\u0000\u0000\u0d62\u0d61\u0001\u0000\u0000\u0000\u0d62"+ + "\u0d63\u0001\u0000\u0000\u0000\u0d63\u0111\u0001\u0000\u0000\u0000\u0d64"+ + "\u0d65\u0005\u00bc\u0000\u0000\u0d65\u0d68\u0005\u023a\u0000\u0000\u0d66"+ + "\u0d67\u0005\u02b3\u0000\u0000\u0d67\u0d69\u0005\u00d3\u0000\u0000\u0d68"+ + "\u0d66\u0001\u0000\u0000\u0000\u0d68\u0d69\u0001\u0000\u0000\u0000\u0d69"+ + "\u0d6a\u0001\u0000\u0000\u0000\u0d6a\u0d6b\u0003\u0202\u0101\u0000\u0d6b"+ + "\u0113\u0001\u0000\u0000\u0000\u0d6c\u0d6d\u0005\u00bc\u0000\u0000\u0d6d"+ + "\u0d6e\u0005\u02f0\u0000\u0000\u0d6e\u0d6f\u0005\u01fa\u0000\u0000\u0d6f"+ + "\u0d72\u0005h\u0000\u0000\u0d70\u0d71\u0005\u02b3\u0000\u0000\u0d71\u0d73"+ + "\u0005\u00d3\u0000\u0000\u0d72\u0d70\u0001\u0000\u0000\u0000\u0d72\u0d73"+ + "\u0001\u0000\u0000\u0000\u0d73\u0d74\u0001\u0000\u0000\u0000\u0d74\u0d76"+ + "\u0003\u0202\u0101\u0000\u0d75\u0d77\u0007\u0001\u0000\u0000\u0d76\u0d75"+ + "\u0001\u0000\u0000\u0000\u0d76\u0d77\u0001\u0000\u0000\u0000\u0d77\u0115"+ + "\u0001\u0000\u0000\u0000\u0d78\u0d79\u0005\u00bc\u0000\u0000\u0d79\u0d7a"+ + "\u0005\u02f0\u0000\u0000\u0d7a\u0d7b\u0005\u01fa\u0000\u0000\u0d7b\u0d7e"+ + "\u0005\u00b2\u0000\u0000\u0d7c\u0d7d\u0005\u02b3\u0000\u0000\u0d7d\u0d7f"+ + "\u0005\u00d3\u0000\u0000\u0d7e\u0d7c\u0001\u0000\u0000\u0000\u0d7e\u0d7f"+ + "\u0001\u0000\u0000\u0000\u0d7f\u0d80\u0001\u0000\u0000\u0000\u0d80\u0d82"+ + "\u0003\u0202\u0101\u0000\u0d81\u0d83\u0007\u0001\u0000\u0000\u0d82\u0d81"+ + "\u0001\u0000\u0000\u0000\u0d82\u0d83\u0001\u0000\u0000\u0000\u0d83\u0117"+ + "\u0001\u0000\u0000\u0000\u0d84\u0d85\u0005\u00bc\u0000\u0000\u0d85\u0d86"+ + "\u0005\u02f0\u0000\u0000\u0d86\u0d87\u0005\u01fa\u0000\u0000\u0d87\u0d8a"+ + "\u0005\u019d\u0000\u0000\u0d88\u0d89\u0005\u02b3\u0000\u0000\u0d89\u0d8b"+ + "\u0005\u00d3\u0000\u0000\u0d8a\u0d88\u0001\u0000\u0000\u0000\u0d8a\u0d8b"+ + "\u0001\u0000\u0000\u0000\u0d8b\u0d8c\u0001\u0000\u0000\u0000\u0d8c\u0d8e"+ + "\u0003\u0202\u0101\u0000\u0d8d\u0d8f\u0007\u0001\u0000\u0000\u0d8e\u0d8d"+ + "\u0001\u0000\u0000\u0000\u0d8e\u0d8f\u0001\u0000\u0000\u0000\u0d8f\u0119"+ + "\u0001\u0000\u0000\u0000\u0d90\u0d91\u0005\u00bc\u0000\u0000\u0d91\u0d92"+ + "\u0005\u02f0\u0000\u0000\u0d92\u0d93\u0005\u01fa\u0000\u0000\u0d93\u0d96"+ + "\u0005\u023c\u0000\u0000\u0d94\u0d95\u0005\u02b3\u0000\u0000\u0d95\u0d97"+ + "\u0005\u00d3\u0000\u0000\u0d96\u0d94\u0001\u0000\u0000\u0000\u0d96\u0d97"+ + "\u0001\u0000\u0000\u0000\u0d97\u0d98\u0001\u0000\u0000\u0000\u0d98\u0d9a"+ + "\u0003\u0202\u0101\u0000\u0d99\u0d9b\u0007\u0001\u0000\u0000\u0d9a\u0d99"+ + "\u0001\u0000\u0000\u0000\u0d9a\u0d9b\u0001\u0000\u0000\u0000\u0d9b\u011b"+ + "\u0001\u0000\u0000\u0000\u0d9c\u0d9d\u0005\u00bc\u0000\u0000\u0d9d\u0da0"+ + "\u0005\u024f\u0000\u0000\u0d9e\u0d9f\u0005\u02b3\u0000\u0000\u0d9f\u0da1"+ + "\u0005\u00d3\u0000\u0000\u0da0\u0d9e\u0001\u0000\u0000\u0000\u0da0\u0da1"+ + "\u0001\u0000\u0000\u0000\u0da1\u0da2\u0001\u0000\u0000\u0000\u0da2\u0da3"+ + "\u0005\u00e3\u0000\u0000\u0da3\u0da4\u0003\u0202\u0101\u0000\u0da4\u0da5"+ + "\u0005\u012b\u0000\u0000\u0da5\u0da6\u0003\u0202\u0101\u0000\u0da6\u0da7"+ + "\u0007\u0001\u0000\u0000\u0da7\u011d\u0001\u0000\u0000\u0000\u0da8\u0da9"+ + "\u0005\u00bc\u0000\u0000\u0da9\u0dac\u0005\u0254\u0000\u0000\u0daa\u0dab"+ + "\u0005\u02b3\u0000\u0000\u0dab\u0dad\u0005\u00d3\u0000\u0000\u0dac\u0daa"+ + "\u0001\u0000\u0000\u0000\u0dac\u0dad\u0001\u0000\u0000\u0000\u0dad\u0dae"+ + "\u0001\u0000\u0000\u0000\u0dae\u0daf\u0003\u0202\u0101\u0000\u0daf\u0db0"+ + "\u0005\u0180\u0000\u0000\u0db0\u0db2\u0003\u0202\u0101\u0000\u0db1\u0db3"+ + "\u0007\u0001\u0000\u0000\u0db2\u0db1\u0001\u0000\u0000\u0000\u0db2\u0db3"+ + "\u0001\u0000\u0000\u0000\u0db3\u011f\u0001\u0000\u0000\u0000\u0db4\u0db5"+ + "\u0005\u00bc\u0000\u0000\u0db5\u0db8\u0005\u025c\u0000\u0000\u0db6\u0db7"+ + "\u0005\u02b3\u0000\u0000\u0db7\u0db9\u0005\u00d3\u0000\u0000\u0db8\u0db6"+ + "\u0001\u0000\u0000\u0000\u0db8\u0db9\u0001\u0000\u0000\u0000\u0db9\u0dba"+ + "\u0001\u0000\u0000\u0000\u0dba\u0dbc\u0003\u01d0\u00e8\u0000\u0dbb\u0dbd"+ + "\u0007\u0001\u0000\u0000\u0dbc\u0dbb\u0001\u0000\u0000\u0000\u0dbc\u0dbd"+ + "\u0001\u0000\u0000\u0000\u0dbd\u0121\u0001\u0000\u0000\u0000\u0dbe\u0dbf"+ + "\u0005\u00bc\u0000\u0000\u0dbf\u0dc2\u0005\u026d\u0000\u0000\u0dc0\u0dc1"+ + "\u0005\u02b3\u0000\u0000\u0dc1\u0dc3\u0005\u00d3\u0000\u0000\u0dc2\u0dc0"+ + "\u0001\u0000\u0000\u0000\u0dc2\u0dc3\u0001\u0000\u0000\u0000\u0dc3\u0dc4"+ + "\u0001\u0000\u0000\u0000\u0dc4\u0dc5\u0003\u01d0\u00e8\u0000\u0dc5\u0123"+ + "\u0001\u0000\u0000\u0000\u0dc6\u0dc7\u0005\u00bc\u0000\u0000\u0dc7\u0dc8"+ + "\u0005\u026d\u0000\u0000\u0dc8\u0dcb\u0005\u0145\u0000\u0000\u0dc9\u0dca"+ + "\u0005\u02b3\u0000\u0000\u0dca\u0dcc\u0005\u00d3\u0000\u0000\u0dcb\u0dc9"+ + "\u0001\u0000\u0000\u0000\u0dcb\u0dcc\u0001\u0000\u0000\u0000\u0dcc\u0dcd"+ + "\u0001\u0000\u0000\u0000\u0dcd\u0dd3\u0005\u00e3\u0000\u0000\u0dce\u0dd4"+ + "\u0003\u01cc\u00e6\u0000\u0dcf\u0dd4\u0005\u026d\u0000\u0000\u0dd0\u0dd4"+ + "\u0005\u008d\u0000\u0000\u0dd1\u0dd4\u0005\u0206\u0000\u0000\u0dd2\u0dd4"+ + "\u0005\u01b9\u0000\u0000\u0dd3\u0dce\u0001\u0000\u0000\u0000\u0dd3\u0dcf"+ + "\u0001\u0000\u0000\u0000\u0dd3\u0dd0\u0001\u0000\u0000\u0000\u0dd3\u0dd1"+ + "\u0001\u0000\u0000\u0000\u0dd3\u0dd2\u0001\u0000\u0000\u0000\u0dd4\u0dd5"+ + "\u0001\u0000\u0000\u0000\u0dd5\u0dd6\u0005\u02bd\u0000\u0000\u0dd6\u0dd7"+ + "\u0003\u0202\u0101\u0000\u0dd7\u0125\u0001\u0000\u0000\u0000\u0dd8\u0dd9"+ + "\u0005\u00bc\u0000\u0000\u0dd9\u0ddc\u0005\u0280\u0000\u0000\u0dda\u0ddb"+ + "\u0005\u02b3\u0000\u0000\u0ddb\u0ddd\u0005\u00d3\u0000\u0000\u0ddc\u0dda"+ + "\u0001\u0000\u0000\u0000\u0ddc\u0ddd\u0001\u0000\u0000\u0000\u0ddd\u0dde"+ + "\u0001\u0000\u0000\u0000\u0dde\u0de0\u0003\u01d0\u00e8\u0000\u0ddf\u0de1"+ + "\u0007\u0001\u0000\u0000\u0de0\u0ddf\u0001\u0000\u0000\u0000\u0de0\u0de1"+ + "\u0001\u0000\u0000\u0000\u0de1\u0127\u0001\u0000\u0000\u0000\u0de2\u0de3"+ + "\u0005\u00d1\u0000\u0000\u0de3\u0de5\u0003\u0202\u0101\u0000\u0de4\u0de6"+ + "\u0003\u01b8\u00dc\u0000\u0de5\u0de4\u0001\u0000\u0000\u0000\u0de5\u0de6"+ + "\u0001\u0000\u0000\u0000\u0de6\u0129\u0001\u0000\u0000\u0000\u0de7\u0de9"+ + "\u0005\u00d5\u0000\u0000\u0de8\u0dea\u0005\u0016\u0000\u0000\u0de9\u0de8"+ + "\u0001\u0000\u0000\u0000\u0de9\u0dea\u0001\u0000\u0000\u0000\u0dea\u0dec"+ + "\u0001\u0000\u0000\u0000\u0deb\u0ded\u0005\u027f\u0000\u0000\u0dec\u0deb"+ + "\u0001\u0000\u0000\u0000\u0dec\u0ded\u0001\u0000\u0000\u0000\u0ded\u0dfb"+ + "\u0001\u0000\u0000\u0000\u0dee\u0def\u0005\u00d5\u0000\u0000\u0def\u0df0"+ + "\u0005\u02ff\u0000\u0000\u0df0\u0df5\u0003\u018e\u00c7\u0000\u0df1\u0df2"+ + "\u0005\u02f9\u0000\u0000\u0df2\u0df4\u0003\u018e\u00c7\u0000\u0df3\u0df1"+ + "\u0001\u0000\u0000\u0000\u0df4\u0df7\u0001\u0000\u0000\u0000\u0df5\u0df3"+ + "\u0001\u0000\u0000\u0000\u0df5\u0df6\u0001\u0000\u0000\u0000\u0df6\u0df8"+ + "\u0001\u0000\u0000\u0000\u0df7\u0df5\u0001\u0000\u0000\u0000\u0df8\u0df9"+ + "\u0005\u0300\u0000\u0000\u0df9\u0dfb\u0001\u0000\u0000\u0000\u0dfa\u0de7"+ + "\u0001\u0000\u0000\u0000\u0dfa\u0dee\u0001\u0000\u0000\u0000\u0dfb\u0e05"+ + "\u0001\u0000\u0000\u0000\u0dfc\u0e06\u0003\u0158\u00ac\u0000\u0dfd\u0e06"+ + "\u0003\u0132\u0099\u0000\u0dfe\u0e06\u0003\u0174\u00ba\u0000\u0dff\u0e06"+ + "\u0003\u00d0h\u0000\u0e00\u0e06\u0003\u017c\u00be\u0000\u0e01\u0e06\u0003"+ + "\u0128\u0094\u0000\u0e02\u0e06\u0003\u00ceg\u0000\u0e03\u0e06\u0003\u00b4"+ + "Z\u0000\u0e04\u0e06\u0003\u0096K\u0000\u0e05\u0dfc\u0001\u0000\u0000\u0000"+ + "\u0e05\u0dfd\u0001\u0000\u0000\u0000\u0e05\u0dfe\u0001\u0000\u0000\u0000"+ + "\u0e05\u0dff\u0001\u0000\u0000\u0000\u0e05\u0e00\u0001\u0000\u0000\u0000"+ + "\u0e05\u0e01\u0001\u0000\u0000\u0000\u0e05\u0e02\u0001\u0000\u0000\u0000"+ + "\u0e05\u0e03\u0001\u0000\u0000\u0000\u0e05\u0e04\u0001\u0000\u0000\u0000"+ + "\u0e06\u012b\u0001\u0000\u0000\u0000\u0e07\u0e08\u0003\u0206\u0103\u0000"+ + "\u0e08\u012d\u0001\u0000\u0000\u0000\u0e09\u0e0a\u0003\u0206\u0103\u0000"+ + "\u0e0a\u012f\u0001\u0000\u0000\u0000\u0e0b\u0e0c\u0003\u0206\u0103\u0000"+ + "\u0e0c\u0131\u0001\u0000\u0000\u0000\u0e0d\u0e0f\u0003\u015c\u00ae\u0000"+ + "\u0e0e\u0e0d\u0001\u0000\u0000\u0000\u0e0e\u0e0f\u0001\u0000\u0000\u0000"+ + "\u0e0f\u0e10\u0001\u0000\u0000\u0000\u0e10\u0e11\u0005\u0116\u0000\u0000"+ + "\u0e11\u0e12\u0005\u011f\u0000\u0000\u0e12\u0e15\u0003\u01d6\u00eb\u0000"+ + "\u0e13\u0e14\u0005\u001b\u0000\u0000\u0e14\u0e16\u0003\u0202\u0101\u0000"+ + "\u0e15\u0e13\u0001\u0000\u0000\u0000\u0e15\u0e16\u0001\u0000\u0000\u0000"+ + "\u0e16\u0e1b\u0001\u0000\u0000\u0000\u0e17\u0e18\u0005\u02ff\u0000\u0000"+ + "\u0e18\u0e19\u0003\u01ce\u00e7\u0000\u0e19\u0e1a\u0005\u0300\u0000\u0000"+ + "\u0e1a\u0e1c\u0001\u0000\u0000\u0000\u0e1b\u0e17\u0001\u0000\u0000\u0000"+ + "\u0e1b\u0e1c\u0001\u0000\u0000\u0000\u0e1c\u0e22\u0001\u0000\u0000\u0000"+ + "\u0e1d\u0e1f\u0005\u0192\u0000\u0000\u0e1e\u0e20\u0007\u0010\u0000\u0000"+ + "\u0e1f\u0e1e\u0001\u0000\u0000\u0000\u0e1f\u0e20\u0001\u0000\u0000\u0000"+ + "\u0e20\u0e21\u0001\u0000\u0000\u0000\u0e21\u0e23\u0005\u0277\u0000\u0000"+ + "\u0e22\u0e1d\u0001\u0000\u0000\u0000\u0e22\u0e23\u0001\u0000\u0000\u0000"+ + "\u0e23\u0e28\u0001\u0000\u0000\u0000\u0e24\u0e25\u0005\u009b\u0000\u0000"+ + "\u0e25\u0e29\u0005\u0278\u0000\u0000\u0e26\u0e29\u0003\u0158\u00ac\u0000"+ + "\u0e27\u0e29\u0003\u017c\u00be\u0000\u0e28\u0e24\u0001\u0000\u0000\u0000"+ + "\u0e28\u0e26\u0001\u0000\u0000\u0000\u0e28\u0e27\u0001\u0000\u0000\u0000"+ + "\u0e29\u0e45\u0001\u0000\u0000\u0000\u0e2a\u0e2b\u0005\u0180\u0000\u0000"+ + "\u0e2b\u0e30\u0005i\u0000\u0000\u0e2c\u0e2d\u0005\u02ff\u0000\u0000\u0e2d"+ + "\u0e2e\u0003\u020a\u0105\u0000\u0e2e\u0e2f\u0005\u0300\u0000\u0000\u0e2f"+ + "\u0e31\u0001\u0000\u0000\u0000\u0e30\u0e2c\u0001\u0000\u0000\u0000\u0e30"+ + "\u0e31\u0001\u0000\u0000\u0000\u0e31\u0e35\u0001\u0000\u0000\u0000\u0e32"+ + "\u0e33\u0005\u0180\u0000\u0000\u0e33\u0e34\u0005m\u0000\u0000\u0e34\u0e36"+ + "\u0003\u020a\u0105\u0000\u0e35\u0e32\u0001\u0000\u0000\u0000\u0e35\u0e36"+ + "\u0001\u0000\u0000\u0000\u0e36\u0e38\u0001\u0000\u0000\u0000\u0e37\u0e39"+ + "\u0003\u0182\u00c1\u0000\u0e38\u0e37\u0001\u0000\u0000\u0000\u0e38\u0e39"+ + "\u0001\u0000\u0000\u0000\u0e39\u0e43\u0001\u0000\u0000\u0000\u0e3a\u0e3b"+ + "\u0005\u00b9\u0000\u0000\u0e3b\u0e44\u0005\u016e\u0000\u0000\u0e3c\u0e3d"+ + "\u0005\u00b9\u0000\u0000\u0e3d\u0e3e\u0005\u026a\u0000\u0000\u0e3e\u0e3f"+ + "\u0005\u0207\u0000\u0000\u0e3f\u0e41\u0003\u01aa\u00d5\u0000\u0e40\u0e42"+ + "\u0003\u0182\u00c1\u0000\u0e41\u0e40\u0001\u0000\u0000\u0000\u0e41\u0e42"+ + "\u0001\u0000\u0000\u0000\u0e42\u0e44\u0001\u0000\u0000\u0000\u0e43\u0e3a"+ + "\u0001\u0000\u0000\u0000\u0e43\u0e3c\u0001\u0000\u0000\u0000\u0e44\u0e46"+ + "\u0001\u0000\u0000\u0000\u0e45\u0e2a\u0001\u0000\u0000\u0000\u0e45\u0e46"+ + "\u0001\u0000\u0000\u0000\u0e46\u0e48\u0001\u0000\u0000\u0000\u0e47\u0e49"+ + "\u0003\u01ae\u00d7\u0000\u0e48\u0e47\u0001\u0000\u0000\u0000\u0e48\u0e49"+ + "\u0001\u0000\u0000\u0000\u0e49\u0133\u0001\u0000\u0000\u0000\u0e4a\u0e4b"+ + "\u0005\u0137\u0000\u0000\u0e4b\u0e4c\u0003\u0202\u0101\u0000\u0e4c\u0135"+ + "\u0001\u0000\u0000\u0000\u0e4d\u0e4e\u0003\u0206\u0103\u0000\u0e4e\u0137"+ + "\u0001\u0000\u0000\u0000\u0e4f\u0e51\u0005\u013f\u0000\u0000\u0e50\u0e52"+ + "\u0005\u0237\u0000\u0000\u0e51\u0e50\u0001\u0000\u0000\u0000\u0e51\u0e52"+ + "\u0001\u0000\u0000\u0000\u0e52\u0e54\u0001\u0000\u0000\u0000\u0e53\u0e55"+ + "\u0005\u0181\u0000\u0000\u0e54\u0e53\u0001\u0000\u0000\u0000\u0e54\u0e55"+ + "\u0001\u0000\u0000\u0000\u0e55\u0e56\u0001\u0000\u0000\u0000\u0e56\u0e58"+ + "\u0003\u01cc\u00e6\u0000\u0e57\u0e59\u0005\u02fe\u0000\u0000\u0e58\u0e57"+ + "\u0001\u0000\u0000\u0000\u0e58\u0e59\u0001\u0000\u0000\u0000\u0e59\u0e6e"+ + "\u0001\u0000\u0000\u0000\u0e5a\u0e6b\u0005\u0109\u0000\u0000\u0e5b\u0e5c"+ + "\u0005\b\u0000\u0000\u0e5c\u0e6c\u0005\u020a\u0000\u0000\u0e5d\u0e5e\u0005"+ + "\u01ec\u0000\u0000\u0e5e\u0e6c\u0005\u020a\u0000\u0000\u0e5f\u0e60\u0005"+ + "\u01ec\u0000\u0000\u0e60\u0e6c\u0005\u00cf\u0000\u0000\u0e61\u0e62\u0005"+ + "\u020a\u0000\u0000\u0e62\u0e63\u0005\u026a\u0000\u0000\u0e63\u0e6c\u0005"+ + "\u00cf\u0000\u0000\u0e64\u0e6c\u0005\u020a\u0000\u0000\u0e65\u0e66\u0005"+ + "\u020a\u0000\u0000\u0e66\u0e67\u0005\u01ec\u0000\u0000\u0e67\u0e6c\u0005"+ + "\u00cf\u0000\u0000\u0e68\u0e6c\u0005\u00cf\u0000\u0000\u0e69\u0e6a\u0005"+ + "\b\u0000\u0000\u0e6a\u0e6c\u0005\u00cf\u0000\u0000\u0e6b\u0e5b\u0001\u0000"+ + "\u0000\u0000\u0e6b\u0e5d\u0001\u0000\u0000\u0000\u0e6b\u0e5f\u0001\u0000"+ + "\u0000\u0000\u0e6b\u0e61\u0001\u0000\u0000\u0000\u0e6b\u0e64\u0001\u0000"+ + "\u0000\u0000\u0e6b\u0e65\u0001\u0000\u0000\u0000\u0e6b\u0e68\u0001\u0000"+ + "\u0000\u0000\u0e6b\u0e69\u0001\u0000\u0000\u0000\u0e6c\u0e6d\u0001\u0000"+ + "\u0000\u0000\u0e6d\u0e6f\u0005\u0155\u0000\u0000\u0e6e\u0e5a\u0001\u0000"+ + "\u0000\u0000\u0e6e\u0e6f\u0001\u0000\u0000\u0000\u0e6f\u0e71\u0001\u0000"+ + "\u0000\u0000\u0e70\u0e72\u0005\u0171\u0000\u0000\u0e71\u0e70\u0001\u0000"+ + "\u0000\u0000\u0e71\u0e72\u0001\u0000\u0000\u0000\u0e72\u0139\u0001\u0000"+ + "\u0000\u0000\u0e73\u0e8b\u0005\u015b\u0000\u0000\u0e74\u0e87\u0005\u0166"+ + "\u0000\u0000\u0e75\u0e87\u0005\u01b5\u0000\u0000\u0e76\u0e87\u0005\u00df"+ + "\u0000\u0000\u0e77\u0e87\u0005\u012d\u0000\u0000\u0e78\u0e79\u0005\u0007"+ + "\u0000\u0000\u0e79\u0e87\u0005\u011b\u0000\u0000\u0e7a\u0e7b\u0005\u01d2"+ + "\u0000\u0000\u0e7b\u0e87\u0005\u0306\u0000\u0000\u0e7c\u0e87\u0005\u0306"+ + "\u0000\u0000\u0e7d\u0e87\u0005\u0010\u0000\u0000\u0e7e\u0e80\u0005\u00e8"+ + "\u0000\u0000\u0e7f\u0e81\u0007\u0011\u0000\u0000\u0e80\u0e7f\u0001\u0000"+ + "\u0000\u0000\u0e80\u0e81\u0001\u0000\u0000\u0000\u0e81\u0e87\u0001\u0000"+ + "\u0000\u0000\u0e82\u0e84\u0005\'\u0000\u0000\u0e83\u0e85\u0007\u0011\u0000"+ + "\u0000\u0e84\u0e83\u0001\u0000\u0000\u0000\u0e84\u0e85\u0001\u0000\u0000"+ + "\u0000\u0e85\u0e87\u0001\u0000\u0000\u0000\u0e86\u0e74\u0001\u0000\u0000"+ + "\u0000\u0e86\u0e75\u0001\u0000\u0000\u0000\u0e86\u0e76\u0001\u0000\u0000"+ + "\u0000\u0e86\u0e77\u0001\u0000\u0000\u0000\u0e86\u0e78\u0001\u0000\u0000"+ + "\u0000\u0e86\u0e7a\u0001\u0000\u0000\u0000\u0e86\u0e7c\u0001\u0000\u0000"+ + "\u0000\u0e86\u0e7d\u0001\u0000\u0000\u0000\u0e86\u0e7e\u0001\u0000\u0000"+ + "\u0000\u0e86\u0e82\u0001\u0000\u0000\u0000\u0e87\u0e89\u0001\u0000\u0000"+ + "\u0000\u0e88\u0e8a\u0007\u0012\u0000\u0000\u0e89\u0e88\u0001\u0000\u0000"+ + "\u0000\u0e89\u0e8a\u0001\u0000\u0000\u0000\u0e8a\u0e8c\u0001\u0000\u0000"+ + "\u0000\u0e8b\u0e86\u0001\u0000\u0000\u0000\u0e8b\u0e8c\u0001\u0000\u0000"+ + "\u0000\u0e8c\u0e8d\u0001\u0000\u0000\u0000\u0e8d\u0e8e\u0003\u01cc\u00e6"+ + "\u0000\u0e8e\u013b\u0001\u0000\u0000\u0000\u0e8f\u0e90\u0005\u016f\u0000"+ + "\u0000\u0e90\u0e93\u0003\u01cc\u00e6\u0000\u0e91\u0e92\u0005\u02f9\u0000"+ + "\u0000\u0e92\u0e94\u0005\u0309\u0000\u0000\u0e93\u0e91\u0001\u0000\u0000"+ + "\u0000\u0e93\u0e94\u0001\u0000\u0000\u0000\u0e94\u013d\u0001\u0000\u0000"+ + "\u0000\u0e95\u0e96\u0005\u01b1\u0000\u0000\u0e96\u0e9b\u0003\u0202\u0101"+ + "\u0000\u0e97\u0e98\u0005\u02ff\u0000\u0000\u0e98\u0e99\u0003\u01da\u00ed"+ + "\u0000\u0e99\u0e9a\u0005\u0300\u0000\u0000\u0e9a\u0e9c\u0001\u0000\u0000"+ + "\u0000\u0e9b\u0e97\u0001\u0000\u0000\u0000\u0e9b\u0e9c\u0001\u0000\u0000"+ + "\u0000\u0e9c\u0e9d\u0001\u0000\u0000\u0000\u0e9d\u0ea3\u0005\u001b\u0000"+ + "\u0000\u0e9e\u0ea4\u0003\u0158\u00ac\u0000\u0e9f\u0ea4\u0003\u0132\u0099"+ + "\u0000\u0ea0\u0ea4\u0003\u0174\u00ba\u0000\u0ea1\u0ea4\u0003\u00d0h\u0000"+ + "\u0ea2\u0ea4\u0003\u017c\u00be\u0000\u0ea3\u0e9e\u0001\u0000\u0000\u0000"+ + "\u0ea3\u0e9f\u0001\u0000\u0000\u0000\u0ea3\u0ea0\u0001\u0000\u0000\u0000"+ + "\u0ea3\u0ea1\u0001\u0000\u0000\u0000\u0ea3\u0ea2\u0001\u0000\u0000\u0000"+ + "\u0ea4\u013f\u0001\u0000\u0000\u0000\u0ea5\u0ea6\u0005\u01b1\u0000\u0000"+ + "\u0ea6\u0ea7\u0005\u024b\u0000\u0000\u0ea7\u0ea8\u0003\u01cc\u00e6\u0000"+ + "\u0ea8\u0141\u0001\u0000\u0000\u0000\u0ea9\u0eaa\u0005\u01c1\u0000\u0000"+ + "\u0eaa\u0eab\u0005\u02cf\u0000\u0000\u0eab\u0eaf\u00056\u0000\u0000\u0eac"+ + "\u0eb0\u0003\u0202\u0101\u0000\u0ead\u0eb0\u0005\u008d\u0000\u0000\u0eae"+ + "\u0eb0\u0005\u0206\u0000\u0000\u0eaf\u0eac\u0001\u0000\u0000\u0000\u0eaf"+ + "\u0ead\u0001\u0000\u0000\u0000\u0eaf\u0eae\u0001\u0000\u0000\u0000\u0eb0"+ + "\u0eb9\u0001\u0000\u0000\u0000\u0eb1\u0eb5\u0005\u02f9\u0000\u0000\u0eb2"+ + "\u0eb6\u0003\u0202\u0101\u0000\u0eb3\u0eb6\u0005\u008d\u0000\u0000\u0eb4"+ + "\u0eb6\u0005\u0206\u0000\u0000\u0eb5\u0eb2\u0001\u0000\u0000\u0000\u0eb5"+ + "\u0eb3\u0001\u0000\u0000\u0000\u0eb5\u0eb4\u0001\u0000\u0000\u0000\u0eb6"+ + "\u0eb8\u0001\u0000\u0000\u0000\u0eb7\u0eb1\u0001\u0000\u0000\u0000\u0eb8"+ + "\u0ebb\u0001\u0000\u0000\u0000\u0eb9\u0eb7\u0001\u0000\u0000\u0000\u0eb9"+ + "\u0eba\u0001\u0000\u0000\u0000\u0eba\u0ebc\u0001\u0000\u0000\u0000\u0ebb"+ + "\u0eb9\u0001\u0000\u0000\u0000\u0ebc\u0ec0\u0005\u0247\u0000\u0000\u0ebd"+ + "\u0ec1\u0003\u0202\u0101\u0000\u0ebe\u0ec1\u0005\u008d\u0000\u0000\u0ebf"+ + "\u0ec1\u0005\u0206\u0000\u0000\u0ec0\u0ebd\u0001\u0000\u0000\u0000\u0ec0"+ + "\u0ebe\u0001\u0000\u0000\u0000\u0ec0\u0ebf\u0001\u0000\u0000\u0000\u0ec1"+ + "\u0143\u0001\u0000\u0000\u0000\u0ec2\u0ec3\u0003\u0206\u0103\u0000\u0ec3"+ + "\u0145\u0001\u0000\u0000\u0000\u0ec4\u0ec8\u0005\u01d1\u0000\u0000\u0ec5"+ + "\u0ec6\u0005\u02ff\u0000\u0000\u0ec6\u0ec7\u0005\u027f\u0000\u0000\u0ec7"+ + "\u0ec9\u0005\u0300\u0000\u0000\u0ec8\u0ec5\u0001\u0000\u0000\u0000\u0ec8"+ + "\u0ec9\u0001\u0000\u0000\u0000\u0ec9\u0eca\u0001\u0000\u0000\u0000\u0eca"+ + "\u0ecb\u0007\u0013\u0000\u0000\u0ecb\u0ecc\u0003\u0202\u0101\u0000\u0ecc"+ + "\u0147\u0001\u0000\u0000\u0000\u0ecd\u0ecf\u0005\u01d3\u0000\u0000\u0ece"+ + "\u0ed0\u0005\u01f1\u0000\u0000\u0ecf\u0ece\u0001\u0000\u0000\u0000\u0ecf"+ + "\u0ed0\u0001\u0000\u0000\u0000\u0ed0\u0ed1\u0001\u0000\u0000\u0000\u0ed1"+ + "\u0ed2\u0003\u0202\u0101\u0000\u0ed2\u0149\u0001\u0000\u0000\u0000\u0ed3"+ + "\u0ed6\u0005\u01d8\u0000\u0000\u0ed4\u0ed7\u0003\u0202\u0101\u0000\u0ed5"+ + "\u0ed7\u0005\u0010\u0000\u0000\u0ed6\u0ed4\u0001\u0000\u0000\u0000\u0ed6"+ + "\u0ed5\u0001\u0000\u0000\u0000\u0ed7\u014b\u0001\u0000\u0000\u0000\u0ed8"+ + "\u0ed9\u0003\u0206\u0103\u0000\u0ed9\u014d\u0001\u0000\u0000\u0000\u0eda"+ + "\u0edc\u0005\u01e6\u0000\u0000\u0edb\u0edd\u0007\u0014\u0000\u0000\u0edc"+ + "\u0edb\u0001\u0000\u0000\u0000\u0edc\u0edd\u0001\u0000\u0000\u0000\u0edd"+ + "\u014f\u0001\u0000\u0000\u0000\u0ede\u0edf\u0005\u01e6\u0000\u0000\u0edf"+ + "\u0ee0\u0005\u01b2\u0000\u0000\u0ee0\u0ee1\u0005\u0306\u0000\u0000\u0ee1"+ + "\u0151\u0001\u0000\u0000\u0000\u0ee2\u0ee4\u0005\u01e6\u0000\u0000\u0ee3"+ + "\u0ee5\u0007\u0014\u0000\u0000\u0ee4\u0ee3\u0001\u0000\u0000\u0000\u0ee4"+ + "\u0ee5\u0001\u0000\u0000\u0000\u0ee5\u0ee6\u0001\u0000\u0000\u0000\u0ee6"+ + "\u0ee8\u0005\u0247\u0000\u0000\u0ee7\u0ee9\u0005\u01f1\u0000\u0000\u0ee8"+ + "\u0ee7\u0001\u0000\u0000\u0000\u0ee8\u0ee9\u0001\u0000\u0000\u0000\u0ee9"+ + "\u0eea\u0001\u0000\u0000\u0000\u0eea\u0eeb\u0003\u0202\u0101\u0000\u0eeb"+ + "\u0153\u0001\u0000\u0000\u0000\u0eec\u0eed\u0005\u01f1\u0000\u0000\u0eed"+ + "\u0eee\u0003\u0202\u0101\u0000\u0eee\u0155\u0001\u0000\u0000\u0000\u0eef"+ + "\u0ef0\u0005\u01fd\u0000\u0000\u0ef0\u0ef3\u0005\u0129\u0000\u0000\u0ef1"+ + "\u0ef2\u0005\u00e3\u0000\u0000\u0ef2\u0ef4\u0003\u01cc\u00e6\u0000\u0ef3"+ + "\u0ef1\u0001\u0000\u0000\u0000\u0ef3\u0ef4\u0001\u0000\u0000\u0000\u0ef4"+ + "\u0ef5\u0001\u0000\u0000\u0000\u0ef5\u0f2c\u0005\u0180\u0000\u0000\u0ef6"+ + "\u0ef7\u0005\u0237\u0000\u0000\u0ef7\u0f2d\u0003\u0202\u0101\u0000\u0ef8"+ + "\u0ef9\u0005^\u0000\u0000\u0ef9\u0efa\u0003\u0202\u0101\u0000\u0efa\u0efb"+ + "\u0005\u0308\u0000\u0000\u0efb\u0efc\u0003\u020a\u0105\u0000\u0efc\u0f2d"+ + "\u0001\u0000\u0000\u0000\u0efd\u0efe\u0005\u000e\u0000\u0000\u0efe\u0eff"+ + "\u0003\u0202\u0101\u0000\u0eff\u0f00\u0005\u02ff\u0000\u0000\u0f00\u0f01"+ + "\u0003\u01ee\u00f7\u0000\u0f01\u0f02\u0005\u0300\u0000\u0000\u0f02\u0f2d"+ + "\u0001\u0000\u0000\u0000\u0f03\u0f04\u0005\u0092\u0000\u0000\u0f04\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f05\u0f06\u0005\u00ba\u0000\u0000\u0f06\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f07\u0f08\u0005\u02bb\u0000\u0000\u0f08\u0f09"+ + "\u0005\u0254\u0000\u0000\u0f09\u0f2d\u0003\u0202\u0101\u0000\u0f0a\u0f0b"+ + "\u0005\u00e5\u0000\u0000\u0f0b\u0f0c\u0005\u0237\u0000\u0000\u0f0c\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f0d\u0f0e\u0005\u00ee\u0000\u0000\u0f0e\u0f0f"+ + "\u0003\u0202\u0101\u0000\u0f0f\u0f10\u0003\u01c0\u00e0\u0000\u0f10\u0f2d"+ + "\u0001\u0000\u0000\u0000\u0f11\u0f12\u0005\u012c\u0000\u0000\u0f12\u0f13"+ + "\u0005\u0178\u0000\u0000\u0f13\u0f2d\u0005\u0306\u0000\u0000\u0f14\u0f15"+ + "\u0005\u02c6\u0000\u0000\u0f15\u0f16\u0005\u0280\u0000\u0000\u0f16\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f17\u0f19\u0005\u01b7\u0000\u0000\u0f18\u0f17"+ + "\u0001\u0000\u0000\u0000\u0f18\u0f19\u0001\u0000\u0000\u0000\u0f19\u0f1a"+ + "\u0001\u0000\u0000\u0000\u0f1a\u0f1b\u0005\u012b\u0000\u0000\u0f1b\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f1c\u0f1d\u0005\u01ba\u0000\u0000\u0f1d\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f1e\u0f1f\u0005\u01e5\u0000\u0000\u0f1f\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f20\u0f21\u0005\u01f3\u0000\u0000\u0f21\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f22\u0f23\u0005\u0201\u0000\u0000\u0f23\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f24\u0f25\u0005\u0230\u0000\u0000\u0f25\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f26\u0f27\u0005\u023a\u0000\u0000\u0f27\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f28\u0f29\u0005\u025c\u0000\u0000\u0f29\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f2a\u0f2b\u0005\u0280\u0000\u0000\u0f2b\u0f2d"+ + "\u0003\u0202\u0101\u0000\u0f2c\u0ef6\u0001\u0000\u0000\u0000\u0f2c\u0ef8"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0efd\u0001\u0000\u0000\u0000\u0f2c\u0f03"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f05\u0001\u0000\u0000\u0000\u0f2c\u0f07"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f0a\u0001\u0000\u0000\u0000\u0f2c\u0f0d"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f11\u0001\u0000\u0000\u0000\u0f2c\u0f14"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f18\u0001\u0000\u0000\u0000\u0f2c\u0f1c"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f1e\u0001\u0000\u0000\u0000\u0f2c\u0f20"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f22\u0001\u0000\u0000\u0000\u0f2c\u0f24"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f26\u0001\u0000\u0000\u0000\u0f2c\u0f28"+ + "\u0001\u0000\u0000\u0000\u0f2c\u0f2a\u0001\u0000\u0000\u0000\u0f2d\u0f2e"+ + "\u0001\u0000\u0000\u0000\u0f2e\u0f2f\u0005\u0121\u0000\u0000\u0f2f\u0f30"+ + "\u0005\u0309\u0000\u0000\u0f30\u0157\u0001\u0000\u0000\u0000\u0f31\u0f33"+ + "\u0003\u015c\u00ae\u0000\u0f32\u0f31\u0001\u0000\u0000\u0000\u0f32\u0f33"+ + "\u0001\u0000\u0000\u0000\u0f33\u0f4e\u0001\u0000\u0000\u0000\u0f34\u0f35"+ + "\u0005\u01fe\u0000\u0000\u0f35\u0f37\u0003\u017e\u00bf\u0000\u0f36\u0f38"+ + "\u0003\u0180\u00c0\u0000\u0f37\u0f36\u0001\u0000\u0000\u0000\u0f37\u0f38"+ + "\u0001\u0000\u0000\u0000\u0f38\u0f4f\u0001\u0000\u0000\u0000\u0f39\u0f3b"+ + "\u0005\u0237\u0000\u0000\u0f3a\u0f3c\u0005\u0181\u0000\u0000\u0f3b\u0f3a"+ + "\u0001\u0000\u0000\u0000\u0f3b\u0f3c\u0001\u0000\u0000\u0000\u0f3c\u0f3d"+ + "\u0001\u0000\u0000\u0000\u0f3d\u0f3f\u0003\u01d6\u00eb\u0000\u0f3e\u0f40"+ + "\u0005\u02fe\u0000\u0000\u0f3f\u0f3e\u0001\u0000\u0000\u0000\u0f3f\u0f40"+ + "\u0001\u0000\u0000\u0000\u0f40\u0f4f\u0001\u0000\u0000\u0000\u0f41\u0f43"+ + "\u0005\u02ff\u0000\u0000\u0f42\u0f41\u0001\u0000\u0000\u0000\u0f43\u0f44"+ + "\u0001\u0000\u0000\u0000\u0f44\u0f42\u0001\u0000\u0000\u0000\u0f44\u0f45"+ + "\u0001\u0000\u0000\u0000\u0f45\u0f46\u0001\u0000\u0000\u0000\u0f46\u0f48"+ + "\u0003\u0158\u00ac\u0000\u0f47\u0f49\u0005\u0300\u0000\u0000\u0f48\u0f47"+ + "\u0001\u0000\u0000\u0000\u0f49\u0f4a\u0001\u0000\u0000\u0000\u0f4a\u0f48"+ + "\u0001\u0000\u0000\u0000\u0f4a\u0f4b\u0001\u0000\u0000\u0000\u0f4b\u0f4c"+ + "\u0001\u0000\u0000\u0000\u0f4c\u0f4d\u0003\u019c\u00ce\u0000\u0f4d\u0f4f"+ + "\u0001\u0000\u0000\u0000\u0f4e\u0f34\u0001\u0000\u0000\u0000\u0f4e\u0f39"+ + "\u0001\u0000\u0000\u0000\u0f4e\u0f42\u0001\u0000\u0000\u0000\u0f4f\u0f51"+ + "\u0001\u0000\u0000\u0000\u0f50\u0f52\u0003\u0182\u00c1\u0000\u0f51\u0f50"+ + "\u0001\u0000\u0000\u0000\u0f51\u0f52\u0001\u0000\u0000\u0000\u0f52\u0f54"+ + "\u0001\u0000\u0000\u0000\u0f53\u0f55\u0003\u0184\u00c2\u0000\u0f54\u0f53"+ + "\u0001\u0000\u0000\u0000\u0f54\u0f55\u0001\u0000\u0000\u0000\u0f55\u0f57"+ + "\u0001\u0000\u0000\u0000\u0f56\u0f58\u0003\u018a\u00c5\u0000\u0f57\u0f56"+ + "\u0001\u0000\u0000\u0000\u0f57\u0f58\u0001\u0000\u0000\u0000\u0f58\u0f5a"+ + "\u0001\u0000\u0000\u0000\u0f59\u0f5b\u0003\u019a\u00cd\u0000\u0f5a\u0f59"+ + "\u0001\u0000\u0000\u0000\u0f5a\u0f5b\u0001\u0000\u0000\u0000\u0f5b\u0f5d"+ + "\u0001\u0000\u0000\u0000\u0f5c\u0f5e\u0003\u019c\u00ce\u0000\u0f5d\u0f5c"+ + "\u0001\u0000\u0000\u0000\u0f5d\u0f5e\u0001\u0000\u0000\u0000\u0f5e\u0f60"+ + "\u0001\u0000\u0000\u0000\u0f5f\u0f61\u0003\u019e\u00cf\u0000\u0f60\u0f5f"+ + "\u0001\u0000\u0000\u0000\u0f60\u0f61\u0001\u0000\u0000\u0000\u0f61\u0f63"+ + "\u0001\u0000\u0000\u0000\u0f62\u0f64\u0003\u01a2\u00d1\u0000\u0f63\u0f62"+ + "\u0001\u0000\u0000\u0000\u0f63\u0f64\u0001\u0000\u0000\u0000\u0f64\u0f66"+ + "\u0001\u0000\u0000\u0000\u0f65\u0f67\u0003\u01a4\u00d2\u0000\u0f66\u0f65"+ + "\u0001\u0000\u0000\u0000\u0f66\u0f67\u0001\u0000\u0000\u0000\u0f67\u0f69"+ + "\u0001\u0000\u0000\u0000\u0f68\u0f6a\u0003\u01a6\u00d3\u0000\u0f69\u0f68"+ + "\u0001\u0000\u0000\u0000\u0f69\u0f6a\u0001\u0000\u0000\u0000\u0f6a\u0f6c"+ + "\u0001\u0000\u0000\u0000\u0f6b\u0f6d\u0003\u01a8\u00d4\u0000\u0f6c\u0f6b"+ + "\u0001\u0000\u0000\u0000\u0f6c\u0f6d\u0001\u0000\u0000\u0000\u0f6d\u0159"+ + "\u0001\u0000\u0000\u0000\u0f6e\u0f70\u0003\u015c\u00ae\u0000\u0f6f\u0f6e"+ + "\u0001\u0000\u0000\u0000\u0f6f\u0f70\u0001\u0000\u0000\u0000\u0f70\u0f93"+ + "\u0001\u0000\u0000\u0000\u0f71\u0f72\u0005\u01fe\u0000\u0000\u0f72\u0f73"+ + "\u0003\u017e\u00bf\u0000\u0f73\u0f75\u0005\u011f\u0000\u0000\u0f74\u0f76"+ + "\u0007\u0015\u0000\u0000\u0f75\u0f74\u0001\u0000\u0000\u0000\u0f75\u0f76"+ + "\u0001\u0000\u0000\u0000\u0f76\u0f78\u0001\u0000\u0000\u0000\u0f77\u0f79"+ + "\u0005\u0237\u0000\u0000\u0f78\u0f77\u0001\u0000\u0000\u0000\u0f78\u0f79"+ + "\u0001\u0000\u0000\u0000\u0f79\u0f7a\u0001\u0000\u0000\u0000\u0f7a\u0f7c"+ + "\u0003\u01d6\u00eb\u0000\u0f7b\u0f7d\u0003\u0180\u00c0\u0000\u0f7c\u0f7b"+ + "\u0001\u0000\u0000\u0000\u0f7c\u0f7d\u0001\u0000\u0000\u0000\u0f7d\u0f94"+ + "\u0001\u0000\u0000\u0000\u0f7e\u0f80\u0005\u0237\u0000\u0000\u0f7f\u0f81"+ + "\u0005\u0181\u0000\u0000\u0f80\u0f7f\u0001\u0000\u0000\u0000\u0f80\u0f81"+ + "\u0001\u0000\u0000\u0000\u0f81\u0f82\u0001\u0000\u0000\u0000\u0f82\u0f84"+ + "\u0003\u01d6\u00eb\u0000\u0f83\u0f85\u0005\u02fe\u0000\u0000\u0f84\u0f83"+ + "\u0001\u0000\u0000\u0000\u0f84\u0f85\u0001\u0000\u0000\u0000\u0f85\u0f94"+ + "\u0001\u0000\u0000\u0000\u0f86\u0f88\u0005\u02ff\u0000\u0000\u0f87\u0f86"+ + "\u0001\u0000\u0000\u0000\u0f88\u0f89\u0001\u0000\u0000\u0000\u0f89\u0f87"+ + "\u0001\u0000\u0000\u0000\u0f89\u0f8a\u0001\u0000\u0000\u0000\u0f8a\u0f8b"+ + "\u0001\u0000\u0000\u0000\u0f8b\u0f8d\u0003\u0158\u00ac\u0000\u0f8c\u0f8e"+ + "\u0005\u0300\u0000\u0000\u0f8d\u0f8c\u0001\u0000\u0000\u0000\u0f8e\u0f8f"+ + "\u0001\u0000\u0000\u0000\u0f8f\u0f8d\u0001\u0000\u0000\u0000\u0f8f\u0f90"+ + "\u0001\u0000\u0000\u0000\u0f90\u0f91\u0001\u0000\u0000\u0000\u0f91\u0f92"+ + "\u0003\u019c\u00ce\u0000\u0f92\u0f94\u0001\u0000\u0000\u0000\u0f93\u0f71"+ + "\u0001\u0000\u0000\u0000\u0f93\u0f7e\u0001\u0000\u0000\u0000\u0f93\u0f87"+ + "\u0001\u0000\u0000\u0000\u0f94\u0f96\u0001\u0000\u0000\u0000\u0f95\u0f97"+ + "\u0003\u0182\u00c1\u0000\u0f96\u0f95\u0001\u0000\u0000\u0000\u0f96\u0f97"+ + "\u0001\u0000\u0000\u0000\u0f97\u0f99\u0001\u0000\u0000\u0000\u0f98\u0f9a"+ + "\u0003\u0184\u00c2\u0000\u0f99\u0f98\u0001\u0000\u0000\u0000\u0f99\u0f9a"+ + "\u0001\u0000\u0000\u0000\u0f9a\u0f9c\u0001\u0000\u0000\u0000\u0f9b\u0f9d"+ + "\u0003\u018a\u00c5\u0000\u0f9c\u0f9b\u0001\u0000\u0000\u0000\u0f9c\u0f9d"+ + "\u0001\u0000\u0000\u0000\u0f9d\u0f9f\u0001\u0000\u0000\u0000\u0f9e\u0fa0"+ + "\u0003\u019a\u00cd\u0000\u0f9f\u0f9e\u0001\u0000\u0000\u0000\u0f9f\u0fa0"+ + "\u0001\u0000\u0000\u0000\u0fa0\u0fa2\u0001\u0000\u0000\u0000\u0fa1\u0fa3"+ + "\u0003\u019c\u00ce\u0000\u0fa2\u0fa1\u0001\u0000\u0000\u0000\u0fa2\u0fa3"+ + "\u0001\u0000\u0000\u0000\u0fa3\u0fa5\u0001\u0000\u0000\u0000\u0fa4\u0fa6"+ + "\u0003\u019e\u00cf\u0000\u0fa5\u0fa4\u0001\u0000\u0000\u0000\u0fa5\u0fa6"+ + "\u0001\u0000\u0000\u0000\u0fa6\u0fa8\u0001\u0000\u0000\u0000\u0fa7\u0fa9"+ + "\u0003\u01a2\u00d1\u0000\u0fa8\u0fa7\u0001\u0000\u0000\u0000\u0fa8\u0fa9"+ + "\u0001\u0000\u0000\u0000\u0fa9\u0fab\u0001\u0000\u0000\u0000\u0faa\u0fac"+ + "\u0003\u01a4\u00d2\u0000\u0fab\u0faa\u0001\u0000\u0000\u0000\u0fab\u0fac"+ + "\u0001\u0000\u0000\u0000\u0fac\u0fae\u0001\u0000\u0000\u0000\u0fad\u0faf"+ + "\u0003\u01a6\u00d3\u0000\u0fae\u0fad\u0001\u0000\u0000\u0000\u0fae\u0faf"+ + "\u0001\u0000\u0000\u0000\u0faf\u0fb1\u0001\u0000\u0000\u0000\u0fb0\u0fb2"+ + "\u0003\u01a8\u00d4\u0000\u0fb1\u0fb0\u0001\u0000\u0000\u0000\u0fb1\u0fb2"+ + "\u0001\u0000\u0000\u0000\u0fb2\u015b\u0001\u0000\u0000\u0000\u0fb3\u0fb5"+ + "\u0005\u0287\u0000\u0000\u0fb4\u0fb6\u0005\u01c3\u0000\u0000\u0fb5\u0fb4"+ + "\u0001\u0000\u0000\u0000\u0fb5\u0fb6\u0001\u0000\u0000\u0000\u0fb6\u0fb7"+ + "\u0001\u0000\u0000\u0000\u0fb7\u0fbc\u0003\u015e\u00af\u0000\u0fb8\u0fb9"+ + "\u0005\u02f9\u0000\u0000\u0fb9\u0fbb\u0003\u015e\u00af\u0000\u0fba\u0fb8"+ + "\u0001\u0000\u0000\u0000\u0fbb\u0fbe\u0001\u0000\u0000\u0000\u0fbc\u0fba"+ + "\u0001\u0000\u0000\u0000\u0fbc\u0fbd\u0001\u0000\u0000\u0000\u0fbd\u015d"+ + "\u0001\u0000\u0000\u0000\u0fbe\u0fbc\u0001\u0000\u0000\u0000\u0fbf\u0fc4"+ + "\u0003\u01d6\u00eb\u0000\u0fc0\u0fc1\u0005\u02ff\u0000\u0000\u0fc1\u0fc2"+ + "\u0003\u01ce\u00e7\u0000\u0fc2\u0fc3\u0005\u0300\u0000\u0000\u0fc3\u0fc5"+ + "\u0001\u0000\u0000\u0000\u0fc4\u0fc0\u0001\u0000\u0000\u0000\u0fc4\u0fc5"+ + "\u0001\u0000\u0000\u0000\u0fc5\u0fc6\u0001\u0000\u0000\u0000\u0fc6\u0fc7"+ + "\u0005\u001b\u0000\u0000\u0fc7\u0fcd\u0005\u02ff\u0000\u0000\u0fc8\u0fce"+ + "\u0003\u0158\u00ac\u0000\u0fc9\u0fce\u0003\u0132\u0099\u0000\u0fca\u0fce"+ + "\u0003\u00d0h\u0000\u0fcb\u0fce\u0003\u0174\u00ba\u0000\u0fcc\u0fce\u0003"+ + "\u017c\u00be\u0000\u0fcd\u0fc8\u0001\u0000\u0000\u0000\u0fcd\u0fc9\u0001"+ + "\u0000\u0000\u0000\u0fcd\u0fca\u0001\u0000\u0000\u0000\u0fcd\u0fcb\u0001"+ + "\u0000\u0000\u0000\u0fcd\u0fcc\u0001\u0000\u0000\u0000\u0fce\u0fcf\u0001"+ + "\u0000\u0000\u0000\u0fcf\u0fd0\u0005\u0300\u0000\u0000\u0fd0\u015f\u0001"+ + "\u0000\u0000\u0000\u0fd1\u0fd3\u0005\u0207\u0000\u0000\u0fd2\u0fd4\u0007"+ + "\u0016\u0000\u0000\u0fd3\u0fd2\u0001\u0000\u0000\u0000\u0fd3\u0fd4\u0001"+ + "\u0000\u0000\u0000\u0fd4\u0fd5\u0001\u0000\u0000\u0000\u0fd5\u0fd6\u0003"+ + "\u0202\u0101\u0000\u0fd6\u0fd9\u0007\u0005\u0000\u0000\u0fd7\u0fda\u0003"+ + "\u01fe\u00ff\u0000\u0fd8\u0fda\u0005\u009b\u0000\u0000\u0fd9\u0fd7\u0001"+ + "\u0000\u0000\u0000\u0fd9\u0fd8\u0001\u0000\u0000\u0000\u0fda\u0fe7\u0001"+ + "\u0000\u0000\u0000\u0fdb\u0fdd\u0005\u0207\u0000\u0000\u0fdc\u0fde\u0007"+ + "\u0016\u0000\u0000\u0fdd\u0fdc\u0001\u0000\u0000\u0000\u0fdd\u0fde\u0001"+ + "\u0000\u0000\u0000\u0fde\u0fdf\u0001\u0000\u0000\u0000\u0fdf\u0fe0\u0005"+ + "\u0242\u0000\u0000\u0fe0\u0fe4\u0005\u028f\u0000\u0000\u0fe1\u0fe5\u0003"+ + "\u01c6\u00e3\u0000\u0fe2\u0fe5\u0005\u013a\u0000\u0000\u0fe3\u0fe5\u0005"+ + "\u009b\u0000\u0000\u0fe4\u0fe1\u0001\u0000\u0000\u0000\u0fe4\u0fe2\u0001"+ + "\u0000\u0000\u0000\u0fe4\u0fe3\u0001\u0000\u0000\u0000\u0fe5\u0fe7\u0001"+ + "\u0000\u0000\u0000\u0fe6\u0fd1\u0001\u0000\u0000\u0000\u0fe6\u0fdb\u0001"+ + "\u0000\u0000\u0000\u0fe7\u0161\u0001\u0000\u0000\u0000\u0fe8\u0fe9\u0005"+ + "\u0207\u0000\u0000\u0fe9\u0fec\u0005q\u0000\u0000\u0fea\u0fed\u0005\u0010"+ + "\u0000\u0000\u0feb\u0fed\u0003\u01d0\u00e8\u0000\u0fec\u0fea\u0001\u0000"+ + "\u0000\u0000\u0fec\u0feb\u0001\u0000\u0000\u0000\u0fed\u0fee\u0001\u0000"+ + "\u0000\u0000\u0fee\u0fef\u0007\u0017\u0000\u0000\u0fef\u0163\u0001\u0000"+ + "\u0000\u0000\u0ff0\u0ff2\u0005\u0207\u0000\u0000\u0ff1\u0ff3\u0007\u0016"+ + "\u0000\u0000\u0ff2\u0ff1\u0001\u0000\u0000\u0000\u0ff2\u0ff3\u0001\u0000"+ + "\u0000\u0000\u0ff3\u0ff4\u0001\u0000\u0000\u0000\u0ff4\u0ff7\u0005\u01e5"+ + "\u0000\u0000\u0ff5\u0ff8\u0003\u01fa\u00fd\u0000\u0ff6\u0ff8\u0005\u016a"+ + "\u0000\u0000\u0ff7\u0ff5\u0001\u0000\u0000\u0000\u0ff7\u0ff6\u0001\u0000"+ + "\u0000\u0000\u0ff8\u0ffc\u0001\u0000\u0000\u0000\u0ff9\u0ffa\u0005\u01d8"+ + "\u0000\u0000\u0ffa\u0ffc\u0005\u01e5\u0000\u0000\u0ffb\u0ff0\u0001\u0000"+ + "\u0000\u0000\u0ffb\u0ff9\u0001\u0000\u0000\u0000\u0ffc\u0165\u0001\u0000"+ + "\u0000\u0000\u0ffd\u0ffe\u0003\u0206\u0103\u0000\u0ffe\u0167\u0001\u0000"+ + "\u0000\u0000\u0fff\u1000\u0005\u0122\u0000\u0000\u1000\u1008\u0005\u0134"+ + "\u0000\u0000\u1001\u1009\u0005\u0203\u0000\u0000\u1002\u1003\u0005\u01d5"+ + "\u0000\u0000\u1003\u1009\u0005\u01be\u0000\u0000\u1004\u1005\u0005\u01be"+ + "\u0000\u0000\u1005\u1009\u0005d\u0000\u0000\u1006\u1007\u0005\u01be\u0000"+ + "\u0000\u1007\u1009\u0005\u025f\u0000\u0000\u1008\u1001\u0001\u0000\u0000"+ + "\u0000\u1008\u1002\u0001\u0000\u0000\u0000\u1008\u1004\u0001\u0000\u0000"+ + "\u0000\u1008\u1006\u0001\u0000\u0000\u0000\u1009\u1013\u0001\u0000\u0000"+ + "\u0000\u100a\u100b\u0005\u01be\u0000\u0000\u100b\u1013\u0005\u028b\u0000"+ + "\u0000\u100c\u100d\u0005\u01be\u0000\u0000\u100d\u1013\u0005\u0181\u0000"+ + "\u0000\u100e\u1010\u0005\u016d\u0000\u0000\u100f\u100e\u0001\u0000\u0000"+ + "\u0000\u100f\u1010\u0001\u0000\u0000\u0000\u1010\u1011\u0001\u0000\u0000"+ + "\u0000\u1011\u1013\u0005\u009e\u0000\u0000\u1012\u0fff\u0001\u0000\u0000"+ + "\u0000\u1012\u100a\u0001\u0000\u0000\u0000\u1012\u100c\u0001\u0000\u0000"+ + "\u0000\u1012\u100f\u0001\u0000\u0000\u0000\u1013\u0169\u0001\u0000\u0000"+ + "\u0000\u1014\u1019\u0003\u0168\u00b4\u0000\u1015\u1016\u0005\u02f9\u0000"+ + "\u0000\u1016\u1018\u0003\u0168\u00b4\u0000\u1017\u1015\u0001\u0000\u0000"+ + "\u0000\u1018\u101b\u0001\u0000\u0000\u0000\u1019\u1017\u0001\u0000\u0000"+ + "\u0000\u1019\u101a\u0001\u0000\u0000\u0000\u101a\u016b\u0001\u0000\u0000"+ + "\u0000\u101b\u1019\u0001\u0000\u0000\u0000\u101c\u101d\u0005\u0207\u0000"+ + "\u0000\u101d\u101e\u0005\u024b\u0000\u0000\u101e\u102a\u0003\u016a\u00b5"+ + "\u0000\u101f\u1020\u0005\u0207\u0000\u0000\u1020\u1021\u0005\u024b\u0000"+ + "\u0000\u1021\u1022\u0005\u0211\u0000\u0000\u1022\u102a\u0005\u0309\u0000"+ + "\u0000\u1023\u1024\u0005\u0207\u0000\u0000\u1024\u1025\u0005\u0205\u0000"+ + "\u0000\u1025\u1026\u0005L\u0000\u0000\u1026\u1027\u0005\u001b\u0000\u0000"+ + "\u1027\u1028\u0005\u024b\u0000\u0000\u1028\u102a\u0003\u016a\u00b5\u0000"+ + "\u1029\u101c\u0001\u0000\u0000\u0000\u1029\u101f\u0001\u0000\u0000\u0000"+ + "\u1029\u1023\u0001\u0000\u0000\u0000\u102a\u016d\u0001\u0000\u0000\u0000"+ + "\u102b\u1030\u0005\u020b\u0000\u0000\u102c\u1031\u0003\u0202\u0101\u0000"+ + "\u102d\u102e\u0005\u0242\u0000\u0000\u102e\u1031\u0005\u028f\u0000\u0000"+ + "\u102f\u1031\u0005\u0010\u0000\u0000\u1030\u102c\u0001\u0000\u0000\u0000"+ + "\u1030\u102d\u0001\u0000\u0000\u0000\u1030\u102f\u0001\u0000\u0000\u0000"+ + "\u1031\u016f\u0001\u0000\u0000\u0000\u1032\u1034\u0005\u025a\u0000\u0000"+ + "\u1033\u1035\u0005\u0237\u0000\u0000\u1034\u1033\u0001\u0000\u0000\u0000"+ + "\u1034\u1035\u0001\u0000\u0000\u0000\u1035\u1037\u0001\u0000\u0000\u0000"+ + "\u1036\u1038\u0005\u0181\u0000\u0000\u1037\u1036\u0001\u0000\u0000\u0000"+ + "\u1037\u1038\u0001\u0000\u0000\u0000\u1038\u1039\u0001\u0000\u0000\u0000"+ + "\u1039\u103b\u0003\u01d6\u00eb\u0000\u103a\u103c\u0005\u02fe\u0000\u0000"+ + "\u103b\u103a\u0001\u0000\u0000\u0000\u103b\u103c\u0001\u0000\u0000\u0000"+ + "\u103c\u1042\u0001\u0000\u0000\u0000\u103d\u103f\u0005\u02f9\u0000\u0000"+ + "\u103e\u1040\u0005\u0181\u0000\u0000\u103f\u103e\u0001\u0000\u0000\u0000"+ + "\u103f\u1040\u0001\u0000\u0000\u0000\u1040\u1041\u0001\u0000\u0000\u0000"+ + "\u1041\u1043\u0003\u01d0\u00e8\u0000\u1042\u103d\u0001\u0000\u0000\u0000"+ + "\u1042\u1043\u0001\u0000\u0000\u0000\u1043\u1046\u0001\u0000\u0000\u0000"+ + "\u1044\u1045\u0007\u0018\u0000\u0000\u1045\u1047\u0005\u0102\u0000\u0000"+ + "\u1046\u1044\u0001\u0000\u0000\u0000\u1046\u1047\u0001\u0000\u0000\u0000"+ + "\u1047\u1049\u0001\u0000\u0000\u0000\u1048\u104a\u0007\u0001\u0000\u0000"+ + "\u1049\u1048\u0001\u0000\u0000\u0000\u1049\u104a\u0001\u0000\u0000\u0000"+ + "\u104a\u0171\u0001\u0000\u0000\u0000\u104b\u104e\u0005\u0265\u0000\u0000"+ + "\u104c\u104f\u0003\u0202\u0101\u0000\u104d\u104f\u0005\u02fe\u0000\u0000"+ + "\u104e\u104c\u0001\u0000\u0000\u0000\u104e\u104d\u0001\u0000\u0000\u0000"+ + "\u104f\u0173\u0001\u0000\u0000\u0000\u1050\u1052\u0003\u015c\u00ae\u0000"+ + "\u1051\u1050\u0001\u0000\u0000\u0000\u1051\u1052\u0001\u0000\u0000\u0000"+ + "\u1052\u1053\u0001\u0000\u0000\u0000\u1053\u1055\u0005\u026a\u0000\u0000"+ + "\u1054\u1056\u0005\u0181\u0000\u0000\u1055\u1054\u0001\u0000\u0000\u0000"+ + "\u1055\u1056\u0001\u0000\u0000\u0000\u1056\u1057\u0001\u0000\u0000\u0000"+ + "\u1057\u1059\u0003\u01d6\u00eb\u0000\u1058\u105a\u0005\u02fe\u0000\u0000"+ + "\u1059\u1058\u0001\u0000\u0000\u0000\u1059\u105a\u0001\u0000\u0000\u0000"+ + "\u105a\u105f\u0001\u0000\u0000\u0000\u105b\u105d\u0005\u001b\u0000\u0000"+ + "\u105c\u105b\u0001\u0000\u0000\u0000\u105c\u105d\u0001\u0000\u0000\u0000"+ + "\u105d\u105e\u0001\u0000\u0000\u0000\u105e\u1060\u0003\u0202\u0101\u0000"+ + "\u105f\u105c\u0001\u0000\u0000\u0000\u105f\u1060\u0001\u0000\u0000\u0000"+ + "\u1060\u1061\u0001\u0000\u0000\u0000\u1061\u1062\u0005\u0207\u0000\u0000"+ + "\u1062\u1064\u0003\u01aa\u00d5\u0000\u1063\u1065\u0003\u0180\u00c0\u0000"+ + "\u1064\u1063\u0001\u0000\u0000\u0000\u1064\u1065\u0001\u0000\u0000\u0000"+ + "\u1065\u106b\u0001\u0000\u0000\u0000\u1066\u106c\u0003\u0182\u00c1\u0000"+ + "\u1067\u1068\u0005\u0284\u0000\u0000\u1068\u1069\u0005\u0085\u0000\u0000"+ + "\u1069\u106a\u0005\u017b\u0000\u0000\u106a\u106c\u0003\u0202\u0101\u0000"+ + "\u106b\u1066\u0001\u0000\u0000\u0000\u106b\u1067\u0001\u0000\u0000\u0000"+ + "\u106b\u106c\u0001\u0000\u0000\u0000\u106c\u106e\u0001\u0000\u0000\u0000"+ + "\u106d\u106f\u0003\u01ae\u00d7\u0000\u106e\u106d\u0001\u0000\u0000\u0000"+ + "\u106e\u106f\u0001\u0000\u0000\u0000\u106f\u0175\u0001\u0000\u0000\u0000"+ + "\u1070\u1071\u0007\u0019\u0000\u0000\u1071\u0177\u0001\u0000\u0000\u0000"+ + "\u1072\u1077\u0003\u0176\u00bb\u0000\u1073\u1074\u0005\u02f9\u0000\u0000"+ + "\u1074\u1076\u0003\u0176\u00bb\u0000\u1075\u1073\u0001\u0000\u0000\u0000"+ + "\u1076\u1079\u0001\u0000\u0000\u0000\u1077\u1075\u0001\u0000\u0000\u0000"+ + "\u1077\u1078\u0001\u0000\u0000\u0000\u1078\u0179\u0001\u0000\u0000\u0000"+ + "\u1079\u1077\u0001\u0000\u0000\u0000\u107a\u107f\u0005\u0273\u0000\u0000"+ + "\u107b\u107c\u0005\u02ff\u0000\u0000\u107c\u107d\u0003\u0178\u00bc\u0000"+ + "\u107d\u107e\u0005\u0300\u0000\u0000\u107e\u1080\u0001\u0000\u0000\u0000"+ + "\u107f\u107b\u0001\u0000\u0000\u0000\u107f\u1080\u0001\u0000\u0000\u0000"+ + "\u1080\u1081\u0001\u0000\u0000\u0000\u1081\u1086\u0003\u01d6\u00eb\u0000"+ + "\u1082\u1083\u0005\u02ff\u0000\u0000\u1083\u1084\u0003\u018c\u00c6\u0000"+ + "\u1084\u1085\u0005\u0300\u0000\u0000\u1085\u1087\u0001\u0000\u0000\u0000"+ + "\u1086\u1082\u0001\u0000\u0000\u0000\u1086\u1087\u0001\u0000\u0000\u0000"+ + "\u1087\u10aa\u0001\u0000\u0000\u0000\u1088\u108a\u0005\u0273\u0000\u0000"+ + "\u1089\u108b\u0005\u00ed\u0000\u0000\u108a\u1089\u0001\u0000\u0000\u0000"+ + "\u108a\u108b\u0001\u0000\u0000\u0000\u108b\u108d\u0001\u0000\u0000\u0000"+ + "\u108c\u108e\u0005\u00eb\u0000\u0000\u108d\u108c\u0001\u0000\u0000\u0000"+ + "\u108d\u108e\u0001\u0000\u0000\u0000\u108e\u1090\u0001\u0000\u0000\u0000"+ + "\u108f\u1091\u0005\u027f\u0000\u0000\u1090\u108f\u0001\u0000\u0000\u0000"+ + "\u1090\u1091\u0001\u0000\u0000\u0000\u1091\u1093\u0001\u0000\u0000\u0000"+ + "\u1092\u1094\u0003\u01d6\u00eb\u0000\u1093\u1092\u0001\u0000\u0000\u0000"+ + "\u1093\u1094\u0001\u0000\u0000\u0000\u1094\u10aa\u0001\u0000\u0000\u0000"+ + "\u1095\u1097\u0005\u0273\u0000\u0000\u1096\u1098\u0005\u00ed\u0000\u0000"+ + "\u1097\u1096\u0001\u0000\u0000\u0000\u1097\u1098\u0001\u0000\u0000\u0000"+ + "\u1098\u109a\u0001\u0000\u0000\u0000\u1099\u109b\u0005\u00eb\u0000\u0000"+ + "\u109a\u1099\u0001\u0000\u0000\u0000\u109a\u109b\u0001\u0000\u0000\u0000"+ + "\u109b\u109d\u0001\u0000\u0000\u0000\u109c\u109e\u0005\u027f\u0000\u0000"+ + "\u109d\u109c\u0001\u0000\u0000\u0000\u109d\u109e\u0001\u0000\u0000\u0000"+ + "\u109e\u109f\u0001\u0000\u0000\u0000\u109f\u10a7\u0005\u0016\u0000\u0000"+ + "\u10a0\u10a5\u0003\u01d6\u00eb\u0000\u10a1\u10a2\u0005\u02ff\u0000\u0000"+ + "\u10a2\u10a3\u0003\u018c\u00c6\u0000\u10a3\u10a4\u0005\u0300\u0000\u0000"+ + "\u10a4\u10a6\u0001\u0000\u0000\u0000\u10a5\u10a1\u0001\u0000\u0000\u0000"+ + "\u10a5\u10a6\u0001\u0000\u0000\u0000\u10a6\u10a8\u0001\u0000\u0000\u0000"+ + "\u10a7\u10a0\u0001\u0000\u0000\u0000\u10a7\u10a8\u0001\u0000\u0000\u0000"+ + "\u10a8\u10aa\u0001\u0000\u0000\u0000\u10a9\u107a\u0001\u0000\u0000\u0000"+ + "\u10a9\u1088\u0001\u0000\u0000\u0000\u10a9\u1095\u0001\u0000\u0000\u0000"+ + "\u10aa\u017b\u0001\u0000\u0000\u0000\u10ab\u10ad\u0003\u015c\u00ae\u0000"+ + "\u10ac\u10ab\u0001\u0000\u0000\u0000\u10ac\u10ad\u0001\u0000\u0000\u0000"+ + "\u10ad\u10bd\u0001\u0000\u0000\u0000\u10ae\u10af\u0005\u0278\u0000\u0000"+ + "\u10af\u10be\u0003\u01ba\u00dd\u0000\u10b0\u10b2\u0005\u02ff\u0000\u0000"+ + "\u10b1\u10b0\u0001\u0000\u0000\u0000\u10b2\u10b3\u0001\u0000\u0000\u0000"+ + "\u10b3\u10b1\u0001\u0000\u0000\u0000\u10b3\u10b4\u0001\u0000\u0000\u0000"+ + "\u10b4\u10b5\u0001\u0000\u0000\u0000\u10b5\u10b7\u0003\u017c\u00be\u0000"+ + "\u10b6\u10b8\u0005\u0300\u0000\u0000\u10b7\u10b6\u0001\u0000\u0000\u0000"+ + "\u10b8\u10b9\u0001\u0000\u0000\u0000\u10b9\u10b7\u0001\u0000\u0000\u0000"+ + "\u10b9\u10ba\u0001\u0000\u0000\u0000\u10ba\u10bb\u0001\u0000\u0000\u0000"+ + "\u10bb\u10bc\u0003\u019c\u00ce\u0000\u10bc\u10be\u0001\u0000\u0000\u0000"+ + "\u10bd\u10ae\u0001\u0000\u0000\u0000\u10bd\u10b1\u0001\u0000\u0000\u0000"+ + "\u10be\u10c0\u0001\u0000\u0000\u0000\u10bf\u10c1\u0003\u019e\u00cf\u0000"+ + "\u10c0\u10bf\u0001\u0000\u0000\u0000\u10c0\u10c1\u0001\u0000\u0000\u0000"+ + "\u10c1\u10c3\u0001\u0000\u0000\u0000\u10c2\u10c4\u0003\u019c\u00ce\u0000"+ + "\u10c3\u10c2\u0001\u0000\u0000\u0000\u10c3\u10c4\u0001\u0000\u0000\u0000"+ + "\u10c4\u10c6\u0001\u0000\u0000\u0000\u10c5\u10c7\u0003\u01a2\u00d1\u0000"+ + "\u10c6\u10c5\u0001\u0000\u0000\u0000\u10c6\u10c7\u0001\u0000\u0000\u0000"+ + "\u10c7\u10c9\u0001\u0000\u0000\u0000\u10c8\u10ca\u0003\u01a4\u00d2\u0000"+ + "\u10c9\u10c8\u0001\u0000\u0000\u0000\u10c9\u10ca\u0001\u0000\u0000\u0000"+ + "\u10ca\u10cc\u0001\u0000\u0000\u0000\u10cb\u10cd\u0003\u01a6\u00d3\u0000"+ + "\u10cc\u10cb\u0001\u0000\u0000\u0000\u10cc\u10cd\u0001\u0000\u0000\u0000"+ + "\u10cd\u017d\u0001\u0000\u0000\u0000\u10ce\u10d5\u0005\u0010\u0000\u0000"+ + "\u10cf\u10d2\u0005\u00b8\u0000\u0000\u10d0\u10d1\u0005\u0180\u0000\u0000"+ + "\u10d1\u10d3\u0003\u01b8\u00dc\u0000\u10d2\u10d0\u0001\u0000\u0000\u0000"+ + "\u10d2\u10d3\u0001\u0000\u0000\u0000\u10d3\u10d5\u0001\u0000\u0000\u0000"+ + "\u10d4\u10ce\u0001\u0000\u0000\u0000\u10d4\u10cf\u0001\u0000\u0000\u0000"+ + "\u10d4\u10d5\u0001\u0000\u0000\u0000\u10d5\u10d6\u0001\u0000\u0000\u0000"+ + "\u10d6\u10d7\u0003\u018c\u00c6\u0000\u10d7\u017f\u0001\u0000\u0000\u0000"+ + "\u10d8\u10d9\u0005\u00ec\u0000\u0000\u10d9\u10de\u0003\u01e4\u00f2\u0000"+ + "\u10da\u10db\u0005\u02f9\u0000\u0000\u10db\u10dd\u0003\u01e4\u00f2\u0000"+ + "\u10dc\u10da\u0001\u0000\u0000\u0000\u10dd\u10e0\u0001\u0000\u0000\u0000"+ + "\u10de\u10dc\u0001\u0000\u0000\u0000\u10de\u10df\u0001\u0000\u0000\u0000"+ + "\u10df\u0181\u0001\u0000\u0000\u0000\u10e0\u10de\u0001\u0000\u0000\u0000"+ + "\u10e1\u10e2\u0005\u0284\u0000\u0000\u10e2\u10e3\u0003\u01ec\u00f6\u0000"+ + "\u10e3\u0183\u0001\u0000\u0000\u0000\u10e4\u10e5\u0005\u00fa\u0000\u0000"+ + "\u10e5\u10e6\u00056\u0000\u0000\u10e6\u10eb\u0003\u0186\u00c3\u0000\u10e7"+ + "\u10e8\u0005\u02f9\u0000\u0000\u10e8\u10ea\u0003\u0186\u00c3\u0000\u10e9"+ + "\u10e7\u0001\u0000\u0000\u0000\u10ea\u10ed\u0001\u0000\u0000\u0000\u10eb"+ + "\u10e9\u0001\u0000\u0000\u0000\u10eb\u10ec\u0001\u0000\u0000\u0000\u10ec"+ + "\u0185\u0001\u0000\u0000\u0000\u10ed\u10eb\u0001\u0000\u0000\u0000\u10ee"+ + "\u10ef\u0005\u02ff\u0000\u0000\u10ef\u1108\u0005\u0300\u0000\u0000\u10f0"+ + "\u1108\u0003\u01b0\u00d8\u0000\u10f1\u1108\u0003\u01b8\u00dc\u0000\u10f2"+ + "\u10f3\u0007\u001a\u0000\u0000\u10f3\u10f6\u0005\u02ff\u0000\u0000\u10f4"+ + "\u10f7\u0003\u01b0\u00d8\u0000\u10f5\u10f7\u0003\u01b8\u00dc\u0000\u10f6"+ + "\u10f4\u0001\u0000\u0000\u0000\u10f6\u10f5\u0001\u0000\u0000\u0000\u10f7"+ + "\u10ff\u0001\u0000\u0000\u0000\u10f8\u10fb\u0005\u02f9\u0000\u0000\u10f9"+ + "\u10fc\u0003\u01b0\u00d8\u0000\u10fa\u10fc\u0003\u01b8\u00dc\u0000\u10fb"+ + "\u10f9\u0001\u0000\u0000\u0000\u10fb\u10fa\u0001\u0000\u0000\u0000\u10fc"+ + "\u10fe\u0001\u0000\u0000\u0000\u10fd\u10f8\u0001\u0000\u0000\u0000\u10fe"+ + "\u1101\u0001\u0000\u0000\u0000\u10ff\u10fd\u0001\u0000\u0000\u0000\u10ff"+ + "\u1100\u0001\u0000\u0000\u0000\u1100\u1102\u0001\u0000\u0000\u0000\u1101"+ + "\u10ff\u0001\u0000\u0000\u0000\u1102\u1103\u0005\u0300\u0000\u0000\u1103"+ + "\u1108\u0001\u0000\u0000\u0000\u1104\u1105\u0005\u00fb\u0000\u0000\u1105"+ + "\u1106\u0005\u0209\u0000\u0000\u1106\u1108\u0003\u0188\u00c4\u0000\u1107"+ + "\u10ee\u0001\u0000\u0000\u0000\u1107\u10f0\u0001\u0000\u0000\u0000\u1107"+ + "\u10f1\u0001\u0000\u0000\u0000\u1107\u10f2\u0001\u0000\u0000\u0000\u1107"+ + "\u1104\u0001\u0000\u0000\u0000\u1108\u0187\u0001\u0000\u0000\u0000\u1109"+ + "\u110a\u0005\u02ff\u0000\u0000\u110a\u110f\u0003\u0186\u00c3\u0000\u110b"+ + "\u110c\u0005\u02f9\u0000\u0000\u110c\u110e\u0003\u0186\u00c3\u0000\u110d"+ + "\u110b\u0001\u0000\u0000\u0000\u110e\u1111\u0001\u0000\u0000\u0000\u110f"+ + "\u110d\u0001\u0000\u0000\u0000\u110f\u1110\u0001\u0000\u0000\u0000\u1110"+ + "\u1112\u0001\u0000\u0000\u0000\u1111\u110f\u0001\u0000\u0000\u0000\u1112"+ + "\u1113\u0005\u0300\u0000\u0000\u1113\u0189\u0001\u0000\u0000\u0000\u1114"+ + "\u1115\u0005\u00fd\u0000\u0000\u1115\u111a\u0003\u01ec\u00f6\u0000\u1116"+ + "\u1117\u0005\u02f9\u0000\u0000\u1117\u1119\u0003\u01ec\u00f6\u0000\u1118"+ + "\u1116\u0001\u0000\u0000\u0000\u1119\u111c\u0001\u0000\u0000\u0000\u111a"+ + "\u1118\u0001\u0000\u0000\u0000\u111a\u111b\u0001\u0000\u0000\u0000\u111b"+ + "\u018b\u0001\u0000\u0000\u0000\u111c\u111a\u0001\u0000\u0000\u0000\u111d"+ + "\u1122\u0003\u01b0\u00d8\u0000\u111e\u1120\u0005\u001b\u0000\u0000\u111f"+ + "\u111e\u0001\u0000\u0000\u0000\u111f\u1120\u0001\u0000\u0000\u0000\u1120"+ + "\u1121\u0001\u0000\u0000\u0000\u1121\u1123\u0003\u01cc\u00e6\u0000\u1122"+ + "\u111f\u0001\u0000\u0000\u0000\u1122\u1123\u0001\u0000\u0000\u0000\u1123"+ + "\u1126\u0001\u0000\u0000\u0000\u1124\u1126\u0005\u02fe\u0000\u0000\u1125"+ + "\u111d\u0001\u0000\u0000\u0000\u1125\u1124\u0001\u0000\u0000\u0000\u1126"+ + "\u1134\u0001\u0000\u0000\u0000\u1127\u1130\u0005\u02f9\u0000\u0000\u1128"+ + "\u112d\u0003\u01b0\u00d8\u0000\u1129\u112b\u0005\u001b\u0000\u0000\u112a"+ + "\u1129\u0001\u0000\u0000\u0000\u112a\u112b\u0001\u0000\u0000\u0000\u112b"+ + "\u112c\u0001\u0000\u0000\u0000\u112c\u112e\u0003\u01cc\u00e6\u0000\u112d"+ + "\u112a\u0001\u0000\u0000\u0000\u112d\u112e\u0001\u0000\u0000\u0000\u112e"+ + "\u1131\u0001\u0000\u0000\u0000\u112f\u1131\u0005\u02fe\u0000\u0000\u1130"+ + "\u1128\u0001\u0000\u0000\u0000\u1130\u112f\u0001\u0000\u0000\u0000\u1131"+ + "\u1133\u0001\u0000\u0000\u0000\u1132\u1127\u0001\u0000\u0000\u0000\u1133"+ + "\u1136\u0001\u0000\u0000\u0000\u1134\u1132\u0001\u0000\u0000\u0000\u1134"+ + "\u1135\u0001\u0000\u0000\u0000\u1135\u018d\u0001\u0000\u0000\u0000\u1136"+ + "\u1134\u0001\u0000\u0000\u0000\u1137\u1139\u0007\u001b\u0000\u0000\u1138"+ + "\u113a\u0003\u01fe\u00ff\u0000\u1139\u1138\u0001\u0000\u0000\u0000\u1139"+ + "\u113a\u0001\u0000\u0000\u0000\u113a\u113e\u0001\u0000\u0000\u0000\u113b"+ + "\u113c\u0005\u00e6\u0000\u0000\u113c\u113e\u0007\u001c\u0000\u0000\u113d"+ + "\u1137\u0001\u0000\u0000\u0000\u113d\u113b\u0001\u0000\u0000\u0000\u113e"+ + "\u018f\u0001\u0000\u0000\u0000\u113f\u1140\u0005\u025e\u0000\u0000\u1140"+ + "\u114a\u0005\u01ad\u0000\u0000\u1141\u1142\u0005\u0306\u0000\u0000\u1142"+ + "\u114a\u0005\u01ad\u0000\u0000\u1143\u1144\u0005\u0085\u0000\u0000\u1144"+ + "\u114a\u0005\u01ec\u0000\u0000\u1145\u1146\u0005\u0306\u0000\u0000\u1146"+ + "\u114a\u0005\u00e2\u0000\u0000\u1147\u1148\u0005\u025e\u0000\u0000\u1148"+ + "\u114a\u0005\u00e2\u0000\u0000\u1149\u113f\u0001\u0000\u0000\u0000\u1149"+ + "\u1141\u0001\u0000\u0000\u0000\u1149\u1143\u0001\u0000\u0000\u0000\u1149"+ + "\u1145\u0001\u0000\u0000\u0000\u1149\u1147\u0001\u0000\u0000\u0000\u114a"+ + "\u0191\u0001\u0000\u0000\u0000\u114b\u114c\u0003\u0190\u00c8\u0000\u114c"+ + "\u0193\u0001\u0000\u0000\u0000\u114d\u114e\u0003\u0190\u00c8\u0000\u114e"+ + "\u0195\u0001\u0000\u0000\u0000\u114f\u1150\u0007\u001d\u0000\u0000\u1150"+ + "\u1158\u0003\u0192\u00c9\u0000\u1151\u1152\u0007\u001d\u0000\u0000\u1152"+ + "\u1153\u0005+\u0000\u0000\u1153\u1154\u0003\u0192\u00c9\u0000\u1154\u1155"+ + "\u0005\u0017\u0000\u0000\u1155\u1156\u0003\u0194\u00ca\u0000\u1156\u1158"+ + "\u0001\u0000\u0000\u0000\u1157\u114f\u0001\u0000\u0000\u0000\u1157\u1151"+ + "\u0001\u0000\u0000\u0000\u1158\u0197\u0001\u0000\u0000\u0000\u1159\u1166"+ + "\u0003\u0212\u0109\u0000\u115a\u115b\u0005\u019f\u0000\u0000\u115b\u115c"+ + "\u00056\u0000\u0000\u115c\u1161\u0003\u01b0\u00d8\u0000\u115d\u115e\u0005"+ + "\u02f9\u0000\u0000\u115e\u1160\u0003\u01b0\u00d8\u0000\u115f\u115d\u0001"+ + "\u0000\u0000\u0000\u1160\u1163\u0001\u0000\u0000\u0000\u1161\u115f\u0001"+ + "\u0000\u0000\u0000\u1161\u1162\u0001\u0000\u0000\u0000\u1162\u1166\u0001"+ + "\u0000\u0000\u0000\u1163\u1161\u0001\u0000\u0000\u0000\u1164\u1166\u0003"+ + "\u019e\u00cf\u0000\u1165\u1159\u0001\u0000\u0000\u0000\u1165\u115a\u0001"+ + "\u0000\u0000\u0000\u1165\u1164\u0001\u0000\u0000\u0000\u1166\u0199\u0001"+ + "\u0000\u0000\u0000\u1167\u1168\u0005\u0286\u0000\u0000\u1168\u1169\u0003"+ + "\u0212\u0109\u0000\u1169\u116a\u0005\u001b\u0000\u0000\u116a\u116b\u0005"+ + "\u02ff\u0000\u0000\u116b\u116c\u0003\u0198\u00cc\u0000\u116c\u116d\u0005"+ + "\u0300\u0000\u0000\u116d\u019b\u0001\u0000\u0000\u0000\u116e\u1170\u0007"+ + "\u001e\u0000\u0000\u116f\u1171\u0007\u001f\u0000\u0000\u1170\u116f\u0001"+ + "\u0000\u0000\u0000\u1170\u1171\u0001\u0000\u0000\u0000\u1171\u1175\u0001"+ + "\u0000\u0000\u0000\u1172\u1174\u0005\u02ff\u0000\u0000\u1173\u1172\u0001"+ + "\u0000\u0000\u0000\u1174\u1177\u0001\u0000\u0000\u0000\u1175\u1173\u0001"+ + "\u0000\u0000\u0000\u1175\u1176\u0001\u0000\u0000\u0000\u1176\u117a\u0001"+ + "\u0000\u0000\u0000\u1177\u1175\u0001\u0000\u0000\u0000\u1178\u117b\u0003"+ + "\u0158\u00ac\u0000\u1179\u117b\u0003\u017c\u00be\u0000\u117a\u1178\u0001"+ + "\u0000\u0000\u0000\u117a\u1179\u0001\u0000\u0000\u0000\u117b\u117f\u0001"+ + "\u0000\u0000\u0000\u117c\u117e\u0005\u0300\u0000\u0000\u117d\u117c\u0001"+ + "\u0000\u0000\u0000\u117e\u1181\u0001\u0000\u0000\u0000\u117f\u117d\u0001"+ + "\u0000\u0000\u0000\u117f\u1180\u0001\u0000\u0000\u0000\u1180\u1183\u0001"+ + "\u0000\u0000\u0000\u1181\u117f\u0001\u0000\u0000\u0000\u1182\u1184\u0003"+ + "\u019c\u00ce\u0000\u1183\u1182"; + private static final String _serializedATNSegment2 = + "\u0001\u0000\u0000\u0000\u1183\u1184\u0001\u0000\u0000\u0000\u1184\u019d"+ + "\u0001\u0000\u0000\u0000\u1185\u1186\u0005\u0188\u0000\u0000\u1186\u1187"+ + "\u00056\u0000\u0000\u1187\u118c\u0003\u01a0\u00d0\u0000\u1188\u1189\u0005"+ + "\u02f9\u0000\u0000\u1189\u118b\u0003\u01a0\u00d0\u0000\u118a\u1188\u0001"+ + "\u0000\u0000\u0000\u118b\u118e\u0001\u0000\u0000\u0000\u118c\u118a\u0001"+ + "\u0000\u0000\u0000\u118c\u118d\u0001\u0000\u0000\u0000\u118d\u019f\u0001"+ + "\u0000\u0000\u0000\u118e\u118c\u0001\u0000\u0000\u0000\u118f\u1192\u0003"+ + "\u01b0\u00d8\u0000\u1190\u1192\u0005\u030a\u0000\u0000\u1191\u118f\u0001"+ + "\u0000\u0000\u0000\u1191\u1190\u0001\u0000\u0000\u0000\u1192\u1197\u0001"+ + "\u0000\u0000\u0000\u1193\u1198\u0005\u001c\u0000\u0000\u1194\u1198\u0005"+ + "\u00ab\u0000\u0000\u1195\u1196\u0005\u0272\u0000\u0000\u1196\u1198\u0003"+ + "\u01b0\u00d8\u0000\u1197\u1193\u0001\u0000\u0000\u0000\u1197\u1194\u0001"+ + "\u0000\u0000\u0000\u1197\u1195\u0001\u0000\u0000\u0000\u1197\u1198\u0001"+ + "\u0000\u0000\u0000\u1198\u11a4\u0001\u0000\u0000\u0000\u1199\u119a\u0005"+ + "\u0175\u0000\u0000\u119a\u119b\u0007 \u0000\u0000\u119b\u11a1\u0001\u0000"+ + "\u0000\u0000\u119c\u119d\u0005\u02f9\u0000\u0000\u119d\u119e\u0005\u0175"+ + "\u0000\u0000\u119e\u11a0\u0007 \u0000\u0000\u119f\u119c\u0001\u0000\u0000"+ + "\u0000\u11a0\u11a3\u0001\u0000\u0000\u0000\u11a1\u119f\u0001\u0000\u0000"+ + "\u0000\u11a1\u11a2\u0001\u0000\u0000\u0000\u11a2\u11a5\u0001\u0000\u0000"+ + "\u0000\u11a3\u11a1\u0001\u0000\u0000\u0000\u11a4\u1199\u0001\u0000\u0000"+ + "\u0000\u11a4\u11a5\u0001\u0000\u0000\u0000\u11a5\u01a1\u0001\u0000\u0000"+ + "\u0000\u11a6\u11aa\u0005\u0136\u0000\u0000\u11a7\u11ab\u0005\u0306\u0000"+ + "\u0000\u11a8\u11ab\u0005\u0010\u0000\u0000\u11a9\u11ab\u0003\u01e0\u00f0"+ + "\u0000\u11aa\u11a7\u0001\u0000\u0000\u0000\u11aa\u11a8\u0001\u0000\u0000"+ + "\u0000\u11aa\u11a9\u0001\u0000\u0000\u0000\u11ab\u01a3\u0001\u0000\u0000"+ + "\u0000\u11ac\u11ad\u0005\u017d\u0000\u0000\u11ad\u11af\u0005\u0306\u0000"+ + "\u0000\u11ae\u11b0\u0007!\u0000\u0000\u11af\u11ae\u0001\u0000\u0000\u0000"+ + "\u11af\u11b0\u0001\u0000\u0000\u0000\u11b0\u01a5\u0001\u0000\u0000\u0000"+ + "\u11b1\u11b2\u0005\u00db\u0000\u0000\u11b2\u11b4\u0007\"\u0000\u0000\u11b3"+ + "\u11b5\u0005\u0306\u0000\u0000\u11b4\u11b3\u0001\u0000\u0000\u0000\u11b4"+ + "\u11b5\u0001\u0000\u0000\u0000\u11b5\u11b6\u0001\u0000\u0000\u0000\u11b6"+ + "\u11b7\u0007!\u0000\u0000\u11b7\u11b8\u0005\u0181\u0000\u0000\u11b8\u01a7"+ + "\u0001\u0000\u0000\u0000\u11b9\u11c1\u0005\u00e3\u0000\u0000\u11ba\u11c2"+ + "\u0005\u026a\u0000\u0000\u11bb\u11bc\u0005\u0167\u0000\u0000\u11bc\u11bd"+ + "\u0005\u0126\u0000\u0000\u11bd\u11c2\u0005\u026a\u0000\u0000\u11be\u11c2"+ + "\u0005\u020a\u0000\u0000\u11bf\u11c0\u0005\u0126\u0000\u0000\u11c0\u11c2"+ + "\u0005\u020a\u0000\u0000\u11c1\u11ba\u0001\u0000\u0000\u0000\u11c1\u11bb"+ + "\u0001\u0000\u0000\u0000\u11c1\u11be\u0001\u0000\u0000\u0000\u11c1\u11bf"+ + "\u0001\u0000\u0000\u0000\u11c2\u11cc\u0001\u0000\u0000\u0000\u11c3\u11c4"+ + "\u0005\u017b\u0000\u0000\u11c4\u11c9\u0003\u01d6\u00eb\u0000\u11c5\u11c6"+ + "\u0005\u02f9\u0000\u0000\u11c6\u11c8\u0003\u01d6\u00eb\u0000\u11c7\u11c5"+ + "\u0001\u0000\u0000\u0000\u11c8\u11cb\u0001\u0000\u0000\u0000\u11c9\u11c7"+ + "\u0001\u0000\u0000\u0000\u11c9\u11ca\u0001\u0000\u0000\u0000\u11ca\u11cd"+ + "\u0001\u0000\u0000\u0000\u11cb\u11c9\u0001\u0000\u0000\u0000\u11cc\u11c3"+ + "\u0001\u0000\u0000\u0000\u11cc\u11cd\u0001\u0000\u0000\u0000\u11cd\u11d3"+ + "\u0001\u0000\u0000\u0000\u11ce\u11d2\u0005\u0171\u0000\u0000\u11cf\u11d0"+ + "\u0005\u020f\u0000\u0000\u11d0\u11d2\u0005\u0140\u0000\u0000\u11d1\u11ce"+ + "\u0001\u0000\u0000\u0000\u11d1\u11cf\u0001\u0000\u0000\u0000\u11d2\u11d5"+ + "\u0001\u0000\u0000\u0000\u11d3\u11d1\u0001\u0000\u0000\u0000\u11d3\u11d4"+ + "\u0001\u0000\u0000\u0000\u11d4\u01a9\u0001\u0000\u0000\u0000\u11d5\u11d3"+ + "\u0001\u0000\u0000\u0000\u11d6\u11db\u0003\u01ac\u00d6\u0000\u11d7\u11d8"+ + "\u0005\u02f9\u0000\u0000\u11d8\u11da\u0003\u01ac\u00d6\u0000\u11d9\u11d7"+ + "\u0001\u0000\u0000\u0000\u11da\u11dd\u0001\u0000\u0000\u0000\u11db\u11d9"+ + "\u0001\u0000\u0000\u0000\u11db\u11dc\u0001\u0000\u0000\u0000\u11dc\u01ab"+ + "\u0001\u0000\u0000\u0000\u11dd\u11db\u0001\u0000\u0000\u0000\u11de\u11e8"+ + "\u0003\u01b0\u00d8\u0000\u11df\u11e0\u0005\u02ff\u0000\u0000\u11e0\u11e1"+ + "\u0003\u01ce\u00e7\u0000\u11e1\u11e2\u0005\u0300\u0000\u0000\u11e2\u11e5"+ + "\u0005\u0318\u0000\u0000\u11e3\u11e6\u0003\u01b0\u00d8\u0000\u11e4\u11e6"+ + "\u0003\u01b8\u00dc\u0000\u11e5\u11e3\u0001\u0000\u0000\u0000\u11e5\u11e4"+ + "\u0001\u0000\u0000\u0000\u11e6\u11e8\u0001\u0000\u0000\u0000\u11e7\u11de"+ + "\u0001\u0000\u0000\u0000\u11e7\u11df\u0001\u0000\u0000\u0000\u11e8\u01ad"+ + "\u0001\u0000\u0000\u0000\u11e9\u11ea\u0005\u01e1\u0000\u0000\u11ea\u11eb"+ + "\u0003\u018c\u00c6\u0000\u11eb\u01af\u0001\u0000\u0000\u0000\u11ec\u11ed"+ + "\u0006\u00d8\uffff\uffff\u0000\u11ed\u1238\u0005\u0172\u0000\u0000\u11ee"+ + "\u1238\u0005\u0086\u0000\u0000\u11ef\u1238\u0005\u0089\u0000\u0000\u11f0"+ + "\u1238\u0005\u008a\u0000\u0000\u11f1\u1238\u0005\u008b\u0000\u0000\u11f2"+ + "\u1238\u0005\u008d\u0000\u0000\u11f3\u1238\u0005\u009b\u0000\u0000\u11f4"+ + "\u1238\u0005\u0306\u0000\u0000\u11f5\u1238\u0005\u0307\u0000\u0000\u11f6"+ + "\u1238\u0005\u0305\u0000\u0000\u11f7\u1238\u0005\u0309\u0000\u0000\u11f8"+ + "\u1238\u0005\u0303\u0000\u0000\u11f9\u1238\u0005\u0304\u0000\u0000\u11fa"+ + "\u11fc\u0005\u02fd\u0000\u0000\u11fb\u11fd\b#\u0000\u0000\u11fc\u11fb"+ + "\u0001\u0000\u0000\u0000\u11fd\u11fe\u0001\u0000\u0000\u0000\u11fe\u11fc"+ + "\u0001\u0000\u0000\u0000\u11fe\u11ff\u0001\u0000\u0000\u0000\u11ff\u1200"+ + "\u0001\u0000\u0000\u0000\u1200\u1238\u0005\u02fd\u0000\u0000\u1201\u1202"+ + "\u0005\u02fc\u0000\u0000\u1202\u1204\u0003\u0202\u0101\u0000\u1203\u1205"+ + "\b#\u0000\u0000\u1204\u1203\u0001\u0000\u0000\u0000\u1205\u1206\u0001"+ + "\u0000\u0000\u0000\u1206\u1204\u0001\u0000\u0000\u0000\u1206\u1207\u0001"+ + "\u0000\u0000\u0000\u1207\u1208\u0001\u0000\u0000\u0000\u1208\u1209\u0005"+ + "\u02fc\u0000\u0000\u1209\u120a\u0003\u0202\u0101\u0000\u120a\u120b\u0005"+ + "\u02fc\u0000\u0000\u120b\u1238\u0001\u0000\u0000\u0000\u120c\u1238\u0003"+ + "\u01b4\u00da\u0000\u120d\u1238\u0003\u017c\u00be\u0000\u120e\u1238\u0003"+ + "\u01b8\u00dc\u0000\u120f\u1210\u0005\u02ff\u0000\u0000\u1210\u1211\u0003"+ + "\u01b0\u00d8\u0000\u1211\u1212\u0005\u0300\u0000\u0000\u1212\u1238\u0001"+ + "\u0000\u0000\u0000\u1213\u1214\u0003\u01c4\u00e2\u0000\u1214\u1215\u0005"+ + "\u0309\u0000\u0000\u1215\u1238\u0001\u0000\u0000\u0000\u1216\u1217\u0007"+ + "$\u0000\u0000\u1217\u1238\u0003\u01b0\u00d8\u001f\u1218\u1219\u0007%\u0000"+ + "\u0000\u1219\u1238\u0003\u01b0\u00d8\u001e\u121a\u121b\u0007&\u0000\u0000"+ + "\u121b\u1238\u0003\u01b0\u00d8\u0012\u121c\u1238\u0003\u01e0\u00f0\u0000"+ + "\u121d\u1238\u0003\u0202\u0101\u0000\u121e\u121f\u0005?\u0000\u0000\u121f"+ + "\u1220\u0005\u02ff\u0000\u0000\u1220\u1221\u0003\u01b0\u00d8\u0000\u1221"+ + "\u1222\u0005\u001b\u0000\u0000\u1222\u1223\u0003\u01d8\u00ec\u0000\u1223"+ + "\u1224\u0005\u0300\u0000\u0000\u1224\u1238\u0001\u0000\u0000\u0000\u1225"+ + "\u1226\u0003\u0208\u0104\u0000\u1226\u1227\u0005\u0308\u0000\u0000\u1227"+ + "\u1228\u0003\u020a\u0105\u0000\u1228\u1238\u0001\u0000\u0000\u0000\u1229"+ + "\u1238\u0003\u01b6\u00db\u0000\u122a\u122b\u0003\u01d8\u00ec\u0000\u122b"+ + "\u122c\u0003\u01b0\u00d8\n\u122c\u1238\u0001\u0000\u0000\u0000\u122d\u1238"+ + "\u0003\u01ca\u00e5\u0000\u122e\u1238\u0003\u01e2\u00f1\u0000\u122f\u1230"+ + "\u0005\u00d3\u0000\u0000\u1230\u1238\u0003\u01b0\u00d8\u0004\u1231\u1238"+ + "\u0005\u030c\u0000\u0000\u1232\u1233\u0005\u02ff\u0000\u0000\u1233\u1234"+ + "\u0003\u0158\u00ac\u0000\u1234\u1235\u0005\u0300\u0000\u0000\u1235\u1238"+ + "\u0001\u0000\u0000\u0000\u1236\u1238\u0003\u01b2\u00d9\u0000\u1237\u11ec"+ + "\u0001\u0000\u0000\u0000\u1237\u11ee\u0001\u0000\u0000\u0000\u1237\u11ef"+ + "\u0001\u0000\u0000\u0000\u1237\u11f0\u0001\u0000\u0000\u0000\u1237\u11f1"+ + "\u0001\u0000\u0000\u0000\u1237\u11f2\u0001\u0000\u0000\u0000\u1237\u11f3"+ + "\u0001\u0000\u0000\u0000\u1237\u11f4\u0001\u0000\u0000\u0000\u1237\u11f5"+ + "\u0001\u0000\u0000\u0000\u1237\u11f6\u0001\u0000\u0000\u0000\u1237\u11f7"+ + "\u0001\u0000\u0000\u0000\u1237\u11f8\u0001\u0000\u0000\u0000\u1237\u11f9"+ + "\u0001\u0000\u0000\u0000\u1237\u11fa\u0001\u0000\u0000\u0000\u1237\u1201"+ + "\u0001\u0000\u0000\u0000\u1237\u120c\u0001\u0000\u0000\u0000\u1237\u120d"+ + "\u0001\u0000\u0000\u0000\u1237\u120e\u0001\u0000\u0000\u0000\u1237\u120f"+ + "\u0001\u0000\u0000\u0000\u1237\u1213\u0001\u0000\u0000\u0000\u1237\u1216"+ + "\u0001\u0000\u0000\u0000\u1237\u1218\u0001\u0000\u0000\u0000\u1237\u121a"+ + "\u0001\u0000\u0000\u0000\u1237\u121c\u0001\u0000\u0000\u0000\u1237\u121d"+ + "\u0001\u0000\u0000\u0000\u1237\u121e\u0001\u0000\u0000\u0000\u1237\u1225"+ + "\u0001\u0000\u0000\u0000\u1237\u1229\u0001\u0000\u0000\u0000\u1237\u122a"+ + "\u0001\u0000\u0000\u0000\u1237\u122d\u0001\u0000\u0000\u0000\u1237\u122e"+ + "\u0001\u0000\u0000\u0000\u1237\u122f\u0001\u0000\u0000\u0000\u1237\u1231"+ + "\u0001\u0000\u0000\u0000\u1237\u1232\u0001\u0000\u0000\u0000\u1237\u1236"+ + "\u0001\u0000\u0000\u0000\u1238\u129c\u0001\u0000\u0000\u0000\u1239\u123a"+ + "\n\u001c\u0000\u0000\u123a\u123b\u0007\'\u0000\u0000\u123b\u129b\u0003"+ + "\u01b0\u00d8\u001d\u123c\u123d\n\u001b\u0000\u0000\u123d\u123e\u0007("+ + "\u0000\u0000\u123e\u129b\u0003\u01b0\u00d8\u001c\u123f\u1240\n\u001a\u0000"+ + "\u0000\u1240\u1241\u0007)\u0000\u0000\u1241\u129b\u0003\u01b0\u00d8\u001b"+ + "\u1242\u1243\n\u0019\u0000\u0000\u1243\u1244\u0007*\u0000\u0000\u1244"+ + "\u129b\u0003\u01b0\u00d8\u001a\u1245\u1249\n\u0018\u0000\u0000\u1246\u1247"+ + "\u0005\u016d\u0000\u0000\u1247\u124a\u0005\u0135\u0000\u0000\u1248\u124a"+ + "\u0005\u0135\u0000\u0000\u1249\u1246\u0001\u0000\u0000\u0000\u1249\u1248"+ + "\u0001\u0000\u0000\u0000\u124a\u124b\u0001\u0000\u0000\u0000\u124b\u129b"+ + "\u0003\u01b0\u00d8\u0019\u124c\u124e\n\u0017\u0000\u0000\u124d\u124f\u0005"+ + "\u016d\u0000\u0000\u124e\u124d\u0001\u0000\u0000\u0000\u124e\u124f\u0001"+ + "\u0000\u0000\u0000\u124f\u1250\u0001\u0000\u0000\u0000\u1250\u1251\u0005"+ + "+\u0000\u0000\u1251\u1252\u0003\u01b0\u00d8\u0000\u1252\u1253\u0005\u0017"+ + "\u0000\u0000\u1253\u1254\u0003\u01b0\u00d8\u0018\u1254\u129b\u0001\u0000"+ + "\u0000\u0000\u1255\u1256\n\u0016\u0000\u0000\u1256\u1257\u0005\u0109\u0000"+ + "\u0000\u1257\u129b\u0003\u01b0\u00d8\u0017\u1258\u1259\n\u0015\u0000\u0000"+ + "\u1259\u125a\u0007+\u0000\u0000\u125a\u129b\u0003\u01b0\u00d8\u0016\u125b"+ + "\u125c\n\u0013\u0000\u0000\u125c\u125e\u0005\u0121\u0000\u0000\u125d\u125f"+ + "\u0005\u016d\u0000\u0000\u125e\u125d\u0001\u0000\u0000\u0000\u125e\u125f"+ + "\u0001\u0000\u0000\u0000\u125f\u1260\u0001\u0000\u0000\u0000\u1260\u1261"+ + "\u0005\u00b8\u0000\u0000\u1261\u1262\u0005\u00ec\u0000\u0000\u1262\u129b"+ + "\u0003\u01b0\u00d8\u0014\u1263\u1264\n\"\u0000\u0000\u1264\u1265\u0005"+ + "\u0301\u0000\u0000\u1265\u1266\u0003\u01b0\u00d8\u0000\u1266\u1267\u0005"+ + "\u0302\u0000\u0000\u1267\u129b\u0001\u0000\u0000\u0000\u1268\u1269\n\u001d"+ + "\u0000\u0000\u1269\u129b\u0005\u0314\u0000\u0000\u126a\u126b\n\u0014\u0000"+ + "\u0000\u126b\u1270\u0005\u0121\u0000\u0000\u126c\u1271\u0003\u01b4\u00da"+ + "\u0000\u126d\u1271\u0005\u0172\u0000\u0000\u126e\u126f\u0005\u016d\u0000"+ + "\u0000\u126f\u1271\u0005\u0172\u0000\u0000\u1270\u126c\u0001\u0000\u0000"+ + "\u0000\u1270\u126d\u0001\u0000\u0000\u0000\u1270\u126e\u0001\u0000\u0000"+ + "\u0000\u1271\u129b\u0001\u0000\u0000\u0000\u1272\u127c\n\f\u0000\u0000"+ + "\u1273\u1275\u0005\u0301\u0000\u0000\u1274\u1276\u0003\u01b0\u00d8\u0000"+ + "\u1275\u1274\u0001\u0000\u0000\u0000\u1275\u1276\u0001\u0000\u0000\u0000"+ + "\u1276\u1277\u0001\u0000\u0000\u0000\u1277\u1279\u0005\u02fa\u0000\u0000"+ + "\u1278\u127a\u0003\u01b0\u00d8\u0000\u1279\u1278\u0001\u0000\u0000\u0000"+ + "\u1279\u127a\u0001\u0000\u0000\u0000\u127a\u127b\u0001\u0000\u0000\u0000"+ + "\u127b\u127d\u0005\u0302\u0000\u0000\u127c\u1273\u0001\u0000\u0000\u0000"+ + "\u127d\u127e\u0001\u0000\u0000\u0000\u127e\u127c\u0001\u0000\u0000\u0000"+ + "\u127e\u127f\u0001\u0000\u0000\u0000\u127f\u129b\u0001\u0000\u0000\u0000"+ + "\u1280\u1283\n\u000b\u0000\u0000\u1281\u1282\u0005\u02fb\u0000\u0000\u1282"+ + "\u1284\u0003\u01d8\u00ec\u0000\u1283\u1281\u0001\u0000\u0000\u0000\u1284"+ + "\u1285\u0001\u0000\u0000\u0000\u1285\u1283\u0001\u0000\u0000\u0000\u1285"+ + "\u1286\u0001\u0000\u0000\u0000\u1286\u129b\u0001\u0000\u0000\u0000\u1287"+ + "\u1288\n\t\u0000\u0000\u1288\u1289\u0005\u0121\u0000\u0000\u1289\u128a"+ + "\u0005\u017b\u0000\u0000\u128a\u128b\u0005\u02ff\u0000\u0000\u128b\u128c"+ + "\u0003\u01d8\u00ec\u0000\u128c\u128d\u0005\u0300\u0000\u0000\u128d\u129b"+ + "\u0001\u0000\u0000\u0000\u128e\u128f\n\b\u0000\u0000\u128f\u1292\u0005"+ + "\u0308\u0000\u0000\u1290\u1293\u0003\u0202\u0101\u0000\u1291\u1293\u0005"+ + "\u02fe\u0000\u0000\u1292\u1290\u0001\u0000\u0000\u0000\u1292\u1291\u0001"+ + "\u0000\u0000\u0000\u1293\u129b\u0001\u0000\u0000\u0000\u1294\u1295\n\u0005"+ + "\u0000\u0000\u1295\u1296\u0005!\u0000\u0000\u1296\u1297\u0005\u0242\u0000"+ + "\u0000\u1297\u1298\u0005\u028f\u0000\u0000\u1298\u1299\u0001\u0000\u0000"+ + "\u0000\u1299\u129b\u0005\u0309\u0000\u0000\u129a\u1239\u0001\u0000\u0000"+ + "\u0000\u129a\u123c\u0001\u0000\u0000\u0000\u129a\u123f\u0001\u0000\u0000"+ + "\u0000\u129a\u1242\u0001\u0000\u0000\u0000\u129a\u1245\u0001\u0000\u0000"+ + "\u0000\u129a\u124c\u0001\u0000\u0000\u0000\u129a\u1255\u0001\u0000\u0000"+ + "\u0000\u129a\u1258\u0001\u0000\u0000\u0000\u129a\u125b\u0001\u0000\u0000"+ + "\u0000\u129a\u1263\u0001\u0000\u0000\u0000\u129a\u1268\u0001\u0000\u0000"+ + "\u0000\u129a\u126a\u0001\u0000\u0000\u0000\u129a\u1272\u0001\u0000\u0000"+ + "\u0000\u129a\u1280\u0001\u0000\u0000\u0000\u129a\u1287\u0001\u0000\u0000"+ + "\u0000\u129a\u128e\u0001\u0000\u0000\u0000\u129a\u1294\u0001\u0000\u0000"+ + "\u0000\u129b\u129e\u0001\u0000\u0000\u0000\u129c\u129a\u0001\u0000\u0000"+ + "\u0000\u129c\u129d\u0001\u0000\u0000\u0000\u129d\u01b1\u0001\u0000\u0000"+ + "\u0000\u129e\u129c\u0001\u0000\u0000\u0000\u129f\u12a0\u0005\u02fa\u0000"+ + "\u0000\u12a0\u12aa\u0005\u0344\u0000\u0000\u12a1\u12a2\u0005\u02fa\u0000"+ + "\u0000\u12a2\u12aa\u0003\u0202\u0101\u0000\u12a3\u12a4\u0005\u0335\u0000"+ + "\u0000\u12a4\u12aa\u0005\u0344\u0000\u0000\u12a5\u12a7\u0005\u0335\u0000"+ + "\u0000\u12a6\u12a8\u0005\u0306\u0000\u0000\u12a7\u12a6\u0001\u0000\u0000"+ + "\u0000\u12a7\u12a8\u0001\u0000\u0000\u0000\u12a8\u12aa\u0001\u0000\u0000"+ + "\u0000\u12a9\u129f\u0001\u0000\u0000\u0000\u12a9\u12a1\u0001\u0000\u0000"+ + "\u0000\u12a9\u12a3\u0001\u0000\u0000\u0000\u12a9\u12a5\u0001\u0000\u0000"+ + "\u0000\u12aa\u01b3\u0001\u0000\u0000\u0000\u12ab\u12ac\u0006\u00da\uffff"+ + "\uffff\u0000\u12ac\u12b1\u0005\u0259\u0000\u0000\u12ad\u12b1\u0005\u00da"+ + "\u0000\u0000\u12ae\u12af\u0005\u016d\u0000\u0000\u12af\u12b1\u0003\u01b4"+ + "\u00da\u0003\u12b0\u12ab\u0001\u0000\u0000\u0000\u12b0\u12ad\u0001\u0000"+ + "\u0000\u0000\u12b0\u12ae\u0001\u0000\u0000\u0000\u12b1\u12ba\u0001\u0000"+ + "\u0000\u0000\u12b2\u12b3\n\u0002\u0000\u0000\u12b3\u12b4\u0005\u0017\u0000"+ + "\u0000\u12b4\u12b9\u0003\u01b4\u00da\u0003\u12b5\u12b6\n\u0001\u0000\u0000"+ + "\u12b6\u12b7\u0005\u0187\u0000\u0000\u12b7\u12b9\u0003\u01b4\u00da\u0002"+ + "\u12b8\u12b2\u0001\u0000\u0000\u0000\u12b8\u12b5\u0001\u0000\u0000\u0000"+ + "\u12b9\u12bc\u0001\u0000\u0000\u0000\u12ba\u12b8\u0001\u0000\u0000\u0000"+ + "\u12ba\u12bb\u0001\u0000\u0000\u0000\u12bb\u01b5\u0001\u0000\u0000\u0000"+ + "\u12bc\u12ba\u0001\u0000\u0000\u0000\u12bd\u12be\u0005>\u0000\u0000\u12be"+ + "\u12c4\u0003\u01b0\u00d8\u0000\u12bf\u12c0\u0005\u0282\u0000\u0000\u12c0"+ + "\u12c1\u0003\u01b0\u00d8\u0000\u12c1\u12c2\u0005\u0240\u0000\u0000\u12c2"+ + "\u12c3\u0003\u01b0\u00d8\u0000\u12c3\u12c5\u0001\u0000\u0000\u0000\u12c4"+ + "\u12bf\u0001\u0000\u0000\u0000\u12c5\u12c6\u0001\u0000\u0000\u0000\u12c6"+ + "\u12c4\u0001\u0000\u0000\u0000\u12c6\u12c7\u0001\u0000\u0000\u0000\u12c7"+ + "\u12ca\u0001\u0000\u0000\u0000\u12c8\u12c9\u0005\u00c2\u0000\u0000\u12c9"+ + "\u12cb\u0003\u01b0\u00d8\u0000\u12ca\u12c8\u0001\u0000\u0000\u0000\u12ca"+ + "\u12cb\u0001\u0000\u0000\u0000\u12cb\u12cc\u0001\u0000\u0000\u0000\u12cc"+ + "\u12cd\u0005\u00c6\u0000\u0000\u12cd\u12df\u0001\u0000\u0000\u0000\u12ce"+ + "\u12d4\u0005>\u0000\u0000\u12cf\u12d0\u0005\u0282\u0000\u0000\u12d0\u12d1"+ + "\u0003\u01ec\u00f6\u0000\u12d1\u12d2\u0005\u0240\u0000\u0000\u12d2\u12d3"+ + "\u0003\u01b0\u00d8\u0000\u12d3\u12d5\u0001\u0000\u0000\u0000\u12d4\u12cf"+ + "\u0001\u0000\u0000\u0000\u12d5\u12d6\u0001\u0000\u0000\u0000\u12d6\u12d4"+ + "\u0001\u0000\u0000\u0000\u12d6\u12d7\u0001\u0000\u0000\u0000\u12d7\u12da"+ + "\u0001\u0000\u0000\u0000\u12d8\u12d9\u0005\u00c2\u0000\u0000\u12d9\u12db"+ + "\u0003\u01b0\u00d8\u0000\u12da\u12d8\u0001\u0000\u0000\u0000\u12da\u12db"+ + "\u0001\u0000\u0000\u0000\u12db\u12dc\u0001\u0000\u0000\u0000\u12dc\u12dd"+ + "\u0005\u00c6\u0000\u0000\u12dd\u12df\u0001\u0000\u0000\u0000\u12de\u12bd"+ + "\u0001\u0000\u0000\u0000\u12de\u12ce\u0001\u0000\u0000\u0000\u12df\u01b7"+ + "\u0001\u0000\u0000\u0000\u12e0\u12e1\u0005\u02ff\u0000\u0000\u12e1\u12e6"+ + "\u0003\u01b0\u00d8\u0000\u12e2\u12e3\u0005\u02f9\u0000\u0000\u12e3\u12e5"+ + "\u0003\u01b0\u00d8\u0000\u12e4\u12e2\u0001\u0000\u0000\u0000\u12e5\u12e8"+ + "\u0001\u0000\u0000\u0000\u12e6\u12e4\u0001\u0000\u0000\u0000\u12e6\u12e7"+ + "\u0001\u0000\u0000\u0000\u12e7\u12e9\u0001\u0000\u0000\u0000\u12e8\u12e6"+ + "\u0001\u0000\u0000\u0000\u12e9\u12ea\u0005\u0300\u0000\u0000\u12ea\u01b9"+ + "\u0001\u0000\u0000\u0000\u12eb\u12ed\u0005\u02ff\u0000\u0000\u12ec\u12eb"+ + "\u0001\u0000\u0000\u0000\u12ec\u12ed\u0001\u0000\u0000\u0000\u12ed\u12ee"+ + "\u0001\u0000\u0000\u0000\u12ee\u12f3\u0003\u01b8\u00dc\u0000\u12ef\u12f0"+ + "\u0005\u02f9\u0000\u0000\u12f0\u12f2\u0003\u01b8\u00dc\u0000\u12f1\u12ef"+ + "\u0001\u0000\u0000\u0000\u12f2\u12f5\u0001\u0000\u0000\u0000\u12f3\u12f1"+ + "\u0001\u0000\u0000\u0000\u12f3\u12f4\u0001\u0000\u0000\u0000\u12f4\u12f7"+ + "\u0001\u0000\u0000\u0000\u12f5\u12f3\u0001\u0000\u0000\u0000\u12f6\u12f8"+ + "\u0005\u0300\u0000\u0000\u12f7\u12f6\u0001\u0000\u0000\u0000\u12f7\u12f8"+ + "\u0001\u0000\u0000\u0000\u12f8\u01bb\u0001\u0000\u0000\u0000\u12f9\u12fb"+ + "\u0007,\u0000\u0000\u12fa\u12f9\u0001\u0000\u0000\u0000\u12fa\u12fb\u0001"+ + "\u0000\u0000\u0000\u12fb\u12fd\u0001\u0000\u0000\u0000\u12fc\u12fe\u0003"+ + "\u0202\u0101\u0000\u12fd\u12fc\u0001\u0000\u0000\u0000\u12fd\u12fe\u0001"+ + "\u0000\u0000\u0000\u12fe\u12ff\u0001\u0000\u0000\u0000\u12ff\u1301\u0003"+ + "\u01d8\u00ec\u0000\u1300\u12fa\u0001\u0000\u0000\u0000\u1300\u1301\u0001"+ + "\u0000\u0000\u0000\u1301\u01bd\u0001\u0000\u0000\u0000\u1302\u1307\u0003"+ + "\u01bc\u00de\u0000\u1303\u1304\u0005\u02f9\u0000\u0000\u1304\u1306\u0003"+ + "\u01bc\u00de\u0000\u1305\u1303\u0001\u0000\u0000\u0000\u1306\u1309\u0001"+ + "\u0000\u0000\u0000\u1307\u1305\u0001\u0000\u0000\u0000\u1307\u1308\u0001"+ + "\u0000\u0000\u0000\u1308\u01bf\u0001\u0000\u0000\u0000\u1309\u1307\u0001"+ + "\u0000\u0000\u0000\u130a\u130f\u0003\u0202\u0101\u0000\u130b\u130c\u0005"+ + "\u02ff\u0000\u0000\u130c\u130d\u0003\u01be\u00df\u0000\u130d\u130e\u0005"+ + "\u0300\u0000\u0000\u130e\u1310\u0001\u0000\u0000\u0000\u130f\u130b\u0001"+ + "\u0000\u0000\u0000\u130f\u1310\u0001\u0000\u0000\u0000\u1310\u01c1\u0001"+ + "\u0000\u0000\u0000\u1311\u1316\u0003\u01c0\u00e0\u0000\u1312\u1313\u0005"+ + "\u02f9\u0000\u0000\u1313\u1315\u0003\u01c0\u00e0\u0000\u1314\u1312\u0001"+ + "\u0000\u0000\u0000\u1315\u1318\u0001\u0000\u0000\u0000\u1316\u1314\u0001"+ + "\u0000\u0000\u0000\u1316\u1317\u0001\u0000\u0000\u0000\u1317\u01c3\u0001"+ + "\u0000\u0000\u0000\u1318\u1316\u0001\u0000\u0000\u0000\u1319\u13aa\u0005"+ + "\u02d0\u0000\u0000\u131a\u13aa\u0005\u02e9\u0000\u0000\u131b\u13aa\u0005"+ + ",\u0000\u0000\u131c\u13aa\u0005\u02d1\u0000\u0000\u131d\u1321\u0005.\u0000"+ + "\u0000\u131e\u131f\u0005\u02ff\u0000\u0000\u131f\u1320\u0005\u0306\u0000"+ + "\u0000\u1320\u1322\u0005\u0300\u0000\u0000\u1321\u131e\u0001\u0000\u0000"+ + "\u0000\u1321\u1322\u0001\u0000\u0000\u0000\u1322\u13aa\u0001\u0000\u0000"+ + "\u0000\u1323\u1327\u0005\u02d2\u0000\u0000\u1324\u1325\u0005\u02ff\u0000"+ + "\u0000\u1325\u1326\u0005\u0306\u0000\u0000\u1326\u1328\u0005\u0300\u0000"+ + "\u0000\u1327\u1324\u0001\u0000\u0000\u0000\u1327\u1328\u0001\u0000\u0000"+ + "\u0000\u1328\u13aa\u0001\u0000\u0000\u0000\u1329\u13aa\u0005\u02d3\u0000"+ + "\u0000\u132a\u13aa\u00052\u0000\u0000\u132b\u13aa\u0005\u02d4\u0000\u0000"+ + "\u132c\u13aa\u0005\u02d5\u0000\u0000\u132d\u1331\u0005E\u0000\u0000\u132e"+ + "\u132f\u0005\u02ff\u0000\u0000\u132f\u1330\u0005\u0306\u0000\u0000\u1330"+ + "\u1332\u0005\u0300\u0000\u0000\u1331\u132e\u0001\u0000\u0000\u0000\u1331"+ + "\u1332\u0001\u0000\u0000\u0000\u1332\u13aa\u0001\u0000\u0000\u0000\u1333"+ + "\u1337\u0005G\u0000\u0000\u1334\u1335\u0005\u02ff\u0000\u0000\u1335\u1336"+ + "\u0005\u0306\u0000\u0000\u1336\u1338\u0005\u0300\u0000\u0000\u1337\u1334"+ + "\u0001\u0000\u0000\u0000\u1337\u1338\u0001\u0000\u0000\u0000\u1338\u13aa"+ + "\u0001\u0000\u0000\u0000\u1339\u133d\u0005\u02d6\u0000\u0000\u133a\u133b"+ + "\u0005\u02ff\u0000\u0000\u133b\u133c\u0005\u0306\u0000\u0000\u133c\u133e"+ + "\u0005\u0300\u0000\u0000\u133d\u133a\u0001\u0000\u0000\u0000\u133d\u133e"+ + "\u0001\u0000\u0000\u0000\u133e\u13aa\u0001\u0000\u0000\u0000\u133f\u13aa"+ + "\u0005\u02d7\u0000\u0000\u1340\u13aa\u0005\u02d8\u0000\u0000\u1341\u13aa"+ + "\u0005\u0093\u0000\u0000\u1342\u1348\u0005\u0099\u0000\u0000\u1343\u1344"+ + "\u0005\u02ff\u0000\u0000\u1344\u1345\u0005\u0306\u0000\u0000\u1345\u1346"+ + "\u0005\u02f9\u0000\u0000\u1346\u1347\u0005\u0306\u0000\u0000\u1347\u1349"+ + "\u0005\u0300\u0000\u0000\u1348\u1343\u0001\u0000\u0000\u0000\u1348\u1349"+ + "\u0001\u0000\u0000\u0000\u1349\u13aa\u0001\u0000\u0000\u0000\u134a\u134b"+ + "\u0005\u00bb\u0000\u0000\u134b\u13aa\u0005\u01ae\u0000\u0000\u134c\u13aa"+ + "\u0005\u02d9\u0000\u0000\u134d\u13aa\u0005\u02da\u0000\u0000\u134e\u13aa"+ + "\u0005\u02db\u0000\u0000\u134f\u13aa\u0005\u011a\u0000\u0000\u1350\u13aa"+ + "\u0005\u02dd\u0000\u0000\u1351\u13aa\u0005\u02dc\u0000\u0000\u1352\u13aa"+ + "\u0005\u02de\u0000\u0000\u1353\u13aa\u0005\u011b\u0000\u0000\u1354\u1356"+ + "\u0005\u011e\u0000\u0000\u1355\u1357\u0005\u00dc\u0000\u0000\u1356\u1355"+ + "\u0001\u0000\u0000\u0000\u1356\u1357\u0001\u0000\u0000\u0000\u1357\u1359"+ + "\u0001\u0000\u0000\u0000\u1358\u135a\u0005\u0306\u0000\u0000\u1359\u1358"+ + "\u0001\u0000\u0000\u0000\u1359\u135a\u0001\u0000\u0000\u0000\u135a\u13aa"+ + "\u0001\u0000\u0000\u0000\u135b\u13aa\u0005\u02df\u0000\u0000\u135c\u13aa"+ + "\u0005\u02e0\u0000\u0000\u135d\u13aa\u0005\u02e1\u0000\u0000\u135e\u13aa"+ + "\u0005\u02e2\u0000\u0000\u135f\u13aa\u0005\u02e3\u0000\u0000\u1360\u13aa"+ + "\u0005\u02e4\u0000\u0000\u1361\u13aa\u0005\u02e5\u0000\u0000\u1362\u1368"+ + "\u0005\u0177\u0000\u0000\u1363\u1364\u0005\u02ff\u0000\u0000\u1364\u1365"+ + "\u0005\u0306\u0000\u0000\u1365\u1366\u0005\u02f9\u0000\u0000\u1366\u1367"+ + "\u0005\u0306\u0000\u0000\u1367\u1369\u0005\u0300\u0000\u0000\u1368\u1363"+ + "\u0001\u0000\u0000\u0000\u1368\u1369\u0001\u0000\u0000\u0000\u1369\u13aa"+ + "\u0001\u0000\u0000\u0000\u136a\u13aa\u0005\u01a2\u0000\u0000\u136b\u13aa"+ + "\u0005\u02e6\u0000\u0000\u136c\u13aa\u0005\u02e7\u0000\u0000\u136d\u13aa"+ + "\u0005\u02e8\u0000\u0000\u136e\u13aa\u0005\u01c0\u0000\u0000\u136f\u13aa"+ + "\u0005\u02ea\u0000\u0000\u1370\u13aa\u0005\u02eb\u0000\u0000\u1371\u13aa"+ + "\u0005\u02ec\u0000\u0000\u1372\u13aa\u0005\u02ed\u0000\u0000\u1373\u13aa"+ + "\u0005\u0210\u0000\u0000\u1374\u13aa\u0005\u02ee\u0000\u0000\u1375\u13aa"+ + "\u0005\u02f0\u0000\u0000\u1376\u137a\u0005\u0242\u0000\u0000\u1377\u1378"+ + "\u0005\u02ff\u0000\u0000\u1378\u1379\u0005\u0306\u0000\u0000\u1379\u137b"+ + "\u0005\u0300\u0000\u0000\u137a\u1377\u0001\u0000\u0000\u0000\u137a\u137b"+ + "\u0001\u0000\u0000\u0000\u137b\u137f\u0001\u0000\u0000\u0000\u137c\u137d"+ + "\u0007-\u0000\u0000\u137d\u137e\u0005\u0242\u0000\u0000\u137e\u1380\u0005"+ + "\u028f\u0000\u0000\u137f\u137c\u0001\u0000\u0000\u0000\u137f\u1380\u0001"+ + "\u0000\u0000\u0000\u1380\u13aa\u0001\u0000\u0000\u0000\u1381\u1385\u0005"+ + "\u0243\u0000\u0000\u1382\u1383\u0005\u02ff\u0000\u0000\u1383\u1384\u0005"+ + "\u0306\u0000\u0000\u1384\u1386\u0005\u0300\u0000\u0000\u1385\u1382\u0001"+ + "\u0000\u0000\u0000\u1385\u1386\u0001\u0000\u0000\u0000\u1386\u138a\u0001"+ + "\u0000\u0000\u0000\u1387\u1388\u0007-\u0000\u0000\u1388\u1389\u0005\u0242"+ + "\u0000\u0000\u1389\u138b\u0005\u028f\u0000\u0000\u138a\u1387\u0001\u0000"+ + "\u0000\u0000\u138a\u138b\u0001\u0000\u0000\u0000\u138b\u13aa\u0001\u0000"+ + "\u0000\u0000\u138c\u1390\u0005\u02f2\u0000\u0000\u138d\u138e\u0005\u02ff"+ + "\u0000\u0000\u138e\u138f\u0005\u0306\u0000\u0000\u138f\u1391\u0005\u0300"+ + "\u0000\u0000\u1390\u138d\u0001\u0000\u0000\u0000\u1390\u1391\u0001\u0000"+ + "\u0000\u0000\u1391\u13aa\u0001\u0000\u0000\u0000\u1392\u1396\u0005\u02f1"+ + "\u0000\u0000\u1393\u1394\u0005\u02ff\u0000\u0000\u1394\u1395\u0005\u0306"+ + "\u0000\u0000\u1395\u1397\u0005\u0300\u0000\u0000\u1396\u1393\u0001\u0000"+ + "\u0000\u0000\u1396\u1397\u0001\u0000\u0000\u0000\u1397\u13aa\u0001\u0000"+ + "\u0000\u0000\u1398\u13aa\u0005\u02f3\u0000\u0000\u1399\u13aa\u0005\u02f4"+ + "\u0000\u0000\u139a\u13aa\u0005\u02f5\u0000\u0000\u139b\u13aa\u0005\u02f6"+ + "\u0000\u0000\u139c\u13a0\u0005\u02f7\u0000\u0000\u139d\u139e\u0005\u02ff"+ + "\u0000\u0000\u139e\u139f\u0005\u0306\u0000\u0000\u139f\u13a1\u0005\u0300"+ + "\u0000\u0000\u13a0\u139d\u0001\u0000\u0000\u0000\u13a0\u13a1\u0001\u0000"+ + "\u0000\u0000\u13a1\u13aa\u0001\u0000\u0000\u0000\u13a2\u13a6\u0005\u027b"+ + "\u0000\u0000\u13a3\u13a4\u0005\u02ff\u0000\u0000\u13a4\u13a5\u0005\u0306"+ + "\u0000\u0000\u13a5\u13a7\u0005\u0300\u0000\u0000\u13a6\u13a3\u0001\u0000"+ + "\u0000\u0000\u13a6\u13a7\u0001\u0000\u0000\u0000\u13a7\u13aa\u0001\u0000"+ + "\u0000\u0000\u13a8\u13aa\u0005\u02f8\u0000\u0000\u13a9\u1319\u0001\u0000"+ + "\u0000\u0000\u13a9\u131a\u0001\u0000\u0000\u0000\u13a9\u131b\u0001\u0000"+ + "\u0000\u0000\u13a9\u131c\u0001\u0000\u0000\u0000\u13a9\u131d\u0001\u0000"+ + "\u0000\u0000\u13a9\u1323\u0001\u0000\u0000\u0000\u13a9\u1329\u0001\u0000"+ + "\u0000\u0000\u13a9\u132a\u0001\u0000\u0000\u0000\u13a9\u132b\u0001\u0000"+ + "\u0000\u0000\u13a9\u132c\u0001\u0000\u0000\u0000\u13a9\u132d\u0001\u0000"+ + "\u0000\u0000\u13a9\u1333\u0001\u0000\u0000\u0000\u13a9\u1339\u0001\u0000"+ + "\u0000\u0000\u13a9\u133f\u0001\u0000\u0000\u0000\u13a9\u1340\u0001\u0000"+ + "\u0000\u0000\u13a9\u1341\u0001\u0000\u0000\u0000\u13a9\u1342\u0001\u0000"+ + "\u0000\u0000\u13a9\u134a\u0001\u0000\u0000\u0000\u13a9\u134c\u0001\u0000"+ + "\u0000\u0000\u13a9\u134d\u0001\u0000\u0000\u0000\u13a9\u134e\u0001\u0000"+ + "\u0000\u0000\u13a9\u134f\u0001\u0000\u0000\u0000\u13a9\u1350\u0001\u0000"+ + "\u0000\u0000\u13a9\u1351\u0001\u0000\u0000\u0000\u13a9\u1352\u0001\u0000"+ + "\u0000\u0000\u13a9\u1353\u0001\u0000\u0000\u0000\u13a9\u1354\u0001\u0000"+ + "\u0000\u0000\u13a9\u135b\u0001\u0000\u0000\u0000\u13a9\u135c\u0001\u0000"+ + "\u0000\u0000\u13a9\u135d\u0001\u0000\u0000\u0000\u13a9\u135e\u0001\u0000"+ + "\u0000\u0000\u13a9\u135f\u0001\u0000\u0000\u0000\u13a9\u1360\u0001\u0000"+ + "\u0000\u0000\u13a9\u1361\u0001\u0000\u0000\u0000\u13a9\u1362\u0001\u0000"+ + "\u0000\u0000\u13a9\u136a\u0001\u0000\u0000\u0000\u13a9\u136b\u0001\u0000"+ + "\u0000\u0000\u13a9\u136c\u0001\u0000\u0000\u0000\u13a9\u136d\u0001\u0000"+ + "\u0000\u0000\u13a9\u136e\u0001\u0000\u0000\u0000\u13a9\u136f\u0001\u0000"+ + "\u0000\u0000\u13a9\u1370\u0001\u0000\u0000\u0000\u13a9\u1371\u0001\u0000"+ + "\u0000\u0000\u13a9\u1372\u0001\u0000\u0000\u0000\u13a9\u1373\u0001\u0000"+ + "\u0000\u0000\u13a9\u1374\u0001\u0000\u0000\u0000\u13a9\u1375\u0001\u0000"+ + "\u0000\u0000\u13a9\u1376\u0001\u0000\u0000\u0000\u13a9\u1381\u0001\u0000"+ + "\u0000\u0000\u13a9\u138c\u0001\u0000\u0000\u0000\u13a9\u1392\u0001\u0000"+ + "\u0000\u0000\u13a9\u1398\u0001\u0000\u0000\u0000\u13a9\u1399\u0001\u0000"+ + "\u0000\u0000\u13a9\u139a\u0001\u0000\u0000\u0000\u13a9\u139b\u0001\u0000"+ + "\u0000\u0000\u13a9\u139c\u0001\u0000\u0000\u0000\u13a9\u13a2\u0001\u0000"+ + "\u0000\u0000\u13a9\u13a8\u0001\u0000\u0000\u0000\u13aa\u01c5\u0001\u0000"+ + "\u0000\u0000\u13ab\u13ac\u0007.\u0000\u0000\u13ac\u01c7\u0001\u0000\u0000"+ + "\u0000\u13ad\u13b2\u0001\u0000\u0000\u0000\u13ae\u13af\u0005\u0121\u0000"+ + "\u0000\u13af\u13b2\u0005\u017b\u0000\u0000\u13b0\u13b2\u0005\u0010\u0000"+ + "\u0000\u13b1\u13ad\u0001\u0000\u0000\u0000\u13b1\u13ae\u0001\u0000\u0000"+ + "\u0000\u13b1\u13b0\u0001\u0000\u0000\u0000\u13b2\u01c9\u0001\u0000\u0000"+ + "\u0000\u13b3\u13b4\u0003\u0202\u0101\u0000\u13b4\u13b6\u0005\u02ff\u0000"+ + "\u0000\u13b5\u13b7\u0007\u001f\u0000\u0000\u13b6\u13b5\u0001\u0000\u0000"+ + "\u0000\u13b6\u13b7\u0001\u0000\u0000\u0000\u13b7\u13b8\u0001\u0000\u0000"+ + "\u0000\u13b8\u13bd\u0003\u01b0\u00d8\u0000\u13b9\u13ba\u0005\u02f9\u0000"+ + "\u0000\u13ba\u13bc\u0003\u01b0\u00d8\u0000\u13bb\u13b9\u0001\u0000\u0000"+ + "\u0000\u13bc\u13bf\u0001\u0000\u0000\u0000\u13bd\u13bb\u0001\u0000\u0000"+ + "\u0000\u13bd\u13be\u0001\u0000\u0000\u0000\u13be\u13c1\u0001\u0000\u0000"+ + "\u0000\u13bf\u13bd\u0001\u0000\u0000\u0000\u13c0\u13c2\u0003\u019e\u00cf"+ + "\u0000\u13c1\u13c0\u0001\u0000\u0000\u0000\u13c1\u13c2\u0001\u0000\u0000"+ + "\u0000\u13c2\u13c3\u0001\u0000\u0000\u0000\u13c3\u13ca\u0005\u0300\u0000"+ + "\u0000\u13c4\u13c5\u0005\u00dd\u0000\u0000\u13c5\u13c6\u0005\u02ff\u0000"+ + "\u0000\u13c6\u13c7\u0005\u0284\u0000\u0000\u13c7\u13c8\u0003\u0182\u00c1"+ + "\u0000\u13c8\u13c9\u0005\u0300\u0000\u0000\u13c9\u13cb\u0001\u0000\u0000"+ + "\u0000\u13ca\u13c4\u0001\u0000\u0000\u0000\u13ca\u13cb\u0001\u0000\u0000"+ + "\u0000\u13cb\u13f3\u0001\u0000\u0000\u0000\u13cc\u13cd\u0003\u0202\u0101"+ + "\u0000\u13cd\u13ce\u0005\u02ff\u0000\u0000\u13ce\u13cf\u0005\u02fe\u0000"+ + "\u0000\u13cf\u13d6\u0005\u0300\u0000\u0000\u13d0\u13d1\u0005\u00dd\u0000"+ + "\u0000\u13d1\u13d2\u0005\u02ff\u0000\u0000\u13d2\u13d3\u0005\u0284\u0000"+ + "\u0000\u13d3\u13d4\u0003\u0182\u00c1\u0000\u13d4\u13d5\u0005\u0300\u0000"+ + "\u0000\u13d5\u13d7\u0001\u0000\u0000\u0000\u13d6\u13d0\u0001\u0000\u0000"+ + "\u0000\u13d6\u13d7\u0001\u0000\u0000\u0000\u13d7\u13f3\u0001\u0000\u0000"+ + "\u0000\u13d8\u13d9\u0003\u0202\u0101\u0000\u13d9\u13e2\u0005\u02ff\u0000"+ + "\u0000\u13da\u13df\u0003\u01b0\u00d8\u0000\u13db\u13dc\u0005\u02f9\u0000"+ + "\u0000\u13dc\u13de\u0003\u01b0\u00d8\u0000\u13dd\u13db\u0001\u0000\u0000"+ + "\u0000\u13de\u13e1\u0001\u0000\u0000\u0000\u13df\u13dd\u0001\u0000\u0000"+ + "\u0000\u13df\u13e0\u0001\u0000\u0000\u0000\u13e0\u13e3\u0001\u0000\u0000"+ + "\u0000\u13e1\u13df\u0001\u0000\u0000\u0000\u13e2\u13da\u0001\u0000\u0000"+ + "\u0000\u13e2\u13e3\u0001\u0000\u0000\u0000\u13e3\u13e4\u0001\u0000\u0000"+ + "\u0000\u13e4\u13e5\u0005\u0300\u0000\u0000\u13e5\u13e6\u0005\u0288\u0000"+ + "\u0000\u13e6\u13e7\u0005\u00fa\u0000\u0000\u13e7\u13e8\u0005\u02ff\u0000"+ + "\u0000\u13e8\u13e9\u0003\u019e\u00cf\u0000\u13e9\u13f0\u0005\u0300\u0000"+ + "\u0000\u13ea\u13eb\u0005\u00dd\u0000\u0000\u13eb\u13ec\u0005\u02ff\u0000"+ + "\u0000\u13ec\u13ed\u0005\u0284\u0000\u0000\u13ed\u13ee\u0003\u0182\u00c1"+ + "\u0000\u13ee\u13ef\u0005\u0300\u0000\u0000\u13ef\u13f1\u0001\u0000\u0000"+ + "\u0000\u13f0\u13ea\u0001\u0000\u0000\u0000\u13f0\u13f1\u0001\u0000\u0000"+ + "\u0000\u13f1\u13f3\u0001\u0000\u0000\u0000\u13f2\u13b3\u0001\u0000\u0000"+ + "\u0000\u13f2\u13cc\u0001\u0000\u0000\u0000\u13f2\u13d8\u0001\u0000\u0000"+ + "\u0000\u13f3\u01cb\u0001\u0000\u0000\u0000\u13f4\u13f7\u0005\u0309\u0000"+ + "\u0000\u13f5\u13f7\u0003\u0202\u0101\u0000\u13f6\u13f4\u0001\u0000\u0000"+ + "\u0000\u13f6\u13f5\u0001\u0000\u0000\u0000\u13f7\u01cd\u0001\u0000\u0000"+ + "\u0000\u13f8\u13fd\u0003\u01cc\u00e6\u0000\u13f9\u13fa\u0005\u02f9\u0000"+ + "\u0000\u13fa\u13fc\u0003\u01cc\u00e6\u0000\u13fb\u13f9\u0001\u0000\u0000"+ + "\u0000\u13fc\u13ff\u0001\u0000\u0000\u0000\u13fd\u13fb\u0001\u0000\u0000"+ + "\u0000\u13fd\u13fe\u0001\u0000\u0000\u0000\u13fe\u01cf\u0001\u0000\u0000"+ + "\u0000\u13ff\u13fd\u0001\u0000\u0000\u0000\u1400\u1405\u0003\u0202\u0101"+ + "\u0000\u1401\u1402\u0005\u02f9\u0000\u0000\u1402\u1404\u0003\u0202\u0101"+ + "\u0000\u1403\u1401\u0001\u0000\u0000\u0000\u1404\u1407\u0001\u0000\u0000"+ + "\u0000\u1405\u1403\u0001\u0000\u0000\u0000\u1405\u1406\u0001\u0000\u0000"+ + "\u0000\u1406\u01d1\u0001\u0000\u0000\u0000\u1407\u1405\u0001\u0000\u0000"+ + "\u0000\u1408\u140b\u0003\u0202\u0101\u0000\u1409\u140a\u0005\u0318\u0000"+ + "\u0000\u140a\u140c\u0003\u01fe\u00ff\u0000\u140b\u1409\u0001\u0000\u0000"+ + "\u0000\u140b\u140c\u0001\u0000\u0000\u0000\u140c\u01d3\u0001\u0000\u0000"+ + "\u0000\u140d\u1412\u0003\u01d2\u00e9\u0000\u140e\u140f\u0005\u02f9\u0000"+ + "\u0000\u140f\u1411\u0003\u01d2\u00e9\u0000\u1410\u140e\u0001\u0000\u0000"+ + "\u0000\u1411\u1414\u0001\u0000\u0000\u0000\u1412\u1410\u0001\u0000\u0000"+ + "\u0000\u1412\u1413\u0001\u0000\u0000\u0000\u1413\u01d5\u0001\u0000\u0000"+ + "\u0000\u1414\u1412\u0001\u0000\u0000\u0000\u1415\u1416\u0003\u0202\u0101"+ + "\u0000\u1416\u01d7\u0001\u0000\u0000\u0000\u1417\u141a\u0003\u01c4\u00e2"+ + "\u0000\u1418\u141a\u0003\u0202\u0101\u0000\u1419\u1417\u0001\u0000\u0000"+ + "\u0000\u1419\u1418\u0001\u0000\u0000\u0000\u141a\u1422\u0001\u0000\u0000"+ + "\u0000\u141b\u141d\u0005\u0301\u0000\u0000\u141c\u141e\u0005\u0306\u0000"+ + "\u0000\u141d\u141c\u0001\u0000\u0000\u0000\u141d\u141e\u0001\u0000\u0000"+ + "\u0000\u141e\u141f\u0001\u0000\u0000\u0000\u141f\u1421\u0005\u0302\u0000"+ + "\u0000\u1420\u141b\u0001\u0000\u0000\u0000\u1421\u1424\u0001\u0000\u0000"+ + "\u0000\u1422\u1420\u0001\u0000\u0000\u0000\u1422\u1423\u0001\u0000\u0000"+ + "\u0000\u1423\u01d9\u0001\u0000\u0000\u0000\u1424\u1422\u0001\u0000\u0000"+ + "\u0000\u1425\u142a\u0003\u01d8\u00ec\u0000\u1426\u1427\u0005\u02f9\u0000"+ + "\u0000\u1427\u1429\u0003\u01d8\u00ec\u0000\u1428\u1426\u0001\u0000\u0000"+ + "\u0000\u1429\u142c\u0001\u0000\u0000\u0000\u142a\u1428\u0001\u0000\u0000"+ + "\u0000\u142a\u142b\u0001\u0000\u0000\u0000\u142b\u01db\u0001\u0000\u0000"+ + "\u0000\u142c\u142a\u0001\u0000\u0000\u0000\u142d\u1430\u0007/\u0000\u0000"+ + "\u142e\u1430\u0003\u0202\u0101\u0000\u142f\u142d\u0001\u0000\u0000\u0000"+ + "\u142f\u142e\u0001\u0000\u0000\u0000\u1430\u01dd\u0001\u0000\u0000\u0000"+ + "\u1431\u1432\u0003\u0202\u0101\u0000\u1432\u01df\u0001\u0000\u0000\u0000"+ + "\u1433\u1434\u0003\u01de\u00ef\u0000\u1434\u1435\u0005\u02ff\u0000\u0000"+ + "\u1435\u1436\u0005\u027d\u0000\u0000\u1436\u1437\u0003\u01b0\u00d8\u0000"+ + "\u1437\u1438\u0005\u0300\u0000\u0000\u1438\u1458\u0001\u0000\u0000\u0000"+ + "\u1439\u143a\u0003\u01de\u00ef\u0000\u143a\u1448\u0005\u02ff\u0000\u0000"+ + "\u143b\u1440\u0003\u01b0\u00d8\u0000\u143c\u143d\u0005\u02f9\u0000\u0000"+ + "\u143d\u143f\u0003\u01b0\u00d8\u0000\u143e\u143c\u0001\u0000\u0000\u0000"+ + "\u143f\u1442\u0001\u0000\u0000\u0000\u1440\u143e\u0001\u0000\u0000\u0000"+ + "\u1440\u1441\u0001\u0000\u0000\u0000\u1441\u1446\u0001\u0000\u0000\u0000"+ + "\u1442\u1440\u0001\u0000\u0000\u0000\u1443\u1444\u0005\u02f9\u0000\u0000"+ + "\u1444\u1445\u0005\u027d\u0000\u0000\u1445\u1447\u0003\u01b0\u00d8\u0000"+ + "\u1446\u1443\u0001\u0000\u0000\u0000\u1446\u1447\u0001\u0000\u0000\u0000"+ + "\u1447\u1449\u0001\u0000\u0000\u0000\u1448\u143b\u0001\u0000\u0000\u0000"+ + "\u1448\u1449\u0001\u0000\u0000\u0000\u1449\u144a\u0001\u0000\u0000\u0000"+ + "\u144a\u144b\u0005\u0300\u0000\u0000\u144b\u1458\u0001\u0000\u0000\u0000"+ + "\u144c\u144d\u0003\u01de\u00ef\u0000\u144d\u144e\u0005\u02ff\u0000\u0000"+ + "\u144e\u144f\u0003\u0204\u0102\u0000\u144f\u1450\u0005\u00ec\u0000\u0000"+ + "\u1450\u1453\u0003\u01b0\u00d8\u0000\u1451\u1452\u0005\u00e3\u0000\u0000"+ + "\u1452\u1454\u0003\u01b0\u00d8\u0000\u1453\u1451\u0001\u0000\u0000\u0000"+ + "\u1453\u1454\u0001\u0000\u0000\u0000\u1454\u1455\u0001\u0000\u0000\u0000"+ + "\u1455\u1456\u0005\u0300\u0000\u0000\u1456\u1458\u0001\u0000\u0000\u0000"+ + "\u1457\u1433\u0001\u0000\u0000\u0000\u1457\u1439\u0001\u0000\u0000\u0000"+ + "\u1457\u144c\u0001\u0000\u0000\u0000\u1458\u01e1\u0001\u0000\u0000\u0000"+ + "\u1459\u145a\u0005\u001a\u0000\u0000\u145a\u1463\u0005\u0301\u0000\u0000"+ + "\u145b\u1460\u0003\u01b0\u00d8\u0000\u145c\u145d\u0005\u02f9\u0000\u0000"+ + "\u145d\u145f\u0003\u01b0\u00d8\u0000\u145e\u145c\u0001\u0000\u0000\u0000"+ + "\u145f\u1462\u0001\u0000\u0000\u0000\u1460\u145e\u0001\u0000\u0000\u0000"+ + "\u1460\u1461\u0001\u0000\u0000\u0000\u1461\u1464\u0001\u0000\u0000\u0000"+ + "\u1462\u1460\u0001\u0000\u0000\u0000\u1463\u145b\u0001\u0000\u0000\u0000"+ + "\u1463\u1464\u0001\u0000\u0000\u0000\u1464\u1465\u0001\u0000\u0000\u0000"+ + "\u1465\u1466\u0005\u0302\u0000\u0000\u1466\u01e3\u0001\u0000\u0000\u0000"+ + "\u1467\u1469\u0006\u00f2\uffff\uffff\u0000\u1468\u146a\u0005\u0181\u0000"+ + "\u0000\u1469\u1468\u0001\u0000\u0000\u0000\u1469\u146a\u0001\u0000\u0000"+ + "\u0000\u146a\u146b\u0001\u0000\u0000\u0000\u146b\u146d\u0003\u01d6\u00eb"+ + "\u0000\u146c\u146e\u0005\u02fe\u0000\u0000\u146d\u146c\u0001\u0000\u0000"+ + "\u0000\u146d\u146e\u0001\u0000\u0000\u0000\u146e\u1470\u0001\u0000\u0000"+ + "\u0000\u146f\u1471\u0003\u01e6\u00f3\u0000\u1470\u146f\u0001\u0000\u0000"+ + "\u0000\u1470\u1471\u0001\u0000\u0000\u0000\u1471\u1485\u0001\u0000\u0000"+ + "\u0000\u1472\u1473\u0005\u0239\u0000\u0000\u1473\u1474\u0003\u0204\u0102"+ + "\u0000\u1474\u1475\u0005\u02ff\u0000\u0000\u1475\u147a\u0003\u01b0\u00d8"+ + "\u0000\u1476\u1477\u0005\u02f9\u0000\u0000\u1477\u1479\u0003\u01b0\u00d8"+ + "\u0000\u1478\u1476\u0001\u0000\u0000\u0000\u1479\u147c\u0001\u0000\u0000"+ + "\u0000\u147a\u1478\u0001\u0000\u0000\u0000\u147a\u147b\u0001\u0000\u0000"+ + "\u0000\u147b\u147d\u0001\u0000\u0000\u0000\u147c\u147a\u0001\u0000\u0000"+ + "\u0000\u147d\u1483\u0005\u0300\u0000\u0000\u147e\u147f\u0005\u01d5\u0000"+ + "\u0000\u147f\u1480\u0005\u02ff\u0000\u0000\u1480\u1481\u0003\u0204\u0102"+ + "\u0000\u1481\u1482\u0005\u0300\u0000\u0000\u1482\u1484\u0001\u0000\u0000"+ + "\u0000\u1483\u147e\u0001\u0000\u0000\u0000\u1483\u1484\u0001\u0000\u0000"+ + "\u0000\u1484\u1486\u0001\u0000\u0000\u0000\u1485\u1472\u0001\u0000\u0000"+ + "\u0000\u1485\u1486\u0001\u0000\u0000\u0000\u1486\u14d2\u0001\u0000\u0000"+ + "\u0000\u1487\u1489\u0005\u012e\u0000\u0000\u1488\u1487\u0001\u0000\u0000"+ + "\u0000\u1488\u1489\u0001\u0000\u0000\u0000\u1489\u148a\u0001\u0000\u0000"+ + "\u0000\u148a\u148b\u0005\u02ff\u0000\u0000\u148b\u148c\u0003\u0002\u0001"+ + "\u0000\u148c\u148e\u0005\u0300\u0000\u0000\u148d\u148f\u0005\u001b\u0000"+ + "\u0000\u148e\u148d\u0001\u0000\u0000\u0000\u148e\u148f\u0001\u0000\u0000"+ + "\u0000\u148f\u1490\u0001\u0000\u0000\u0000\u1490\u149c\u0003\u020c\u0106"+ + "\u0000\u1491\u1492\u0005\u02ff\u0000\u0000\u1492\u1497\u0003\u020e\u0107"+ + "\u0000\u1493\u1494\u0005\u02f9\u0000\u0000\u1494\u1496\u0003\u020e\u0107"+ + "\u0000\u1495\u1493\u0001\u0000\u0000\u0000\u1496\u1499\u0001\u0000\u0000"+ + "\u0000\u1497\u1495\u0001\u0000\u0000\u0000\u1497\u1498\u0001\u0000\u0000"+ + "\u0000\u1498\u149a\u0001\u0000\u0000\u0000\u1499\u1497\u0001\u0000\u0000"+ + "\u0000\u149a\u149b\u0005\u0300\u0000\u0000\u149b\u149d\u0001\u0000\u0000"+ + "\u0000\u149c\u1491\u0001\u0000\u0000\u0000\u149c\u149d\u0001\u0000\u0000"+ + "\u0000\u149d\u14d2\u0001\u0000\u0000\u0000\u149e\u14a0\u0005\u012e\u0000"+ + "\u0000\u149f\u149e\u0001\u0000\u0000\u0000\u149f\u14a0\u0001\u0000\u0000"+ + "\u0000\u14a0\u14a1\u0001\u0000\u0000\u0000\u14a1\u14a4\u0003\u01e0\u00f0"+ + "\u0000\u14a2\u14a3\u0005\u0287\u0000\u0000\u14a3\u14a5\u0005\u018a\u0000"+ + "\u0000\u14a4\u14a2\u0001\u0000\u0000\u0000\u14a4\u14a5\u0001\u0000\u0000"+ + "\u0000\u14a5\u14a7\u0001\u0000\u0000\u0000\u14a6\u14a8\u0003\u01e6\u00f3"+ + "\u0000\u14a7\u14a6\u0001\u0000\u0000\u0000\u14a7\u14a8\u0001\u0000\u0000"+ + "\u0000\u14a8\u14d2\u0001\u0000\u0000\u0000\u14a9\u14ab\u0005\u012e\u0000"+ + "\u0000\u14aa\u14a9\u0001\u0000\u0000\u0000\u14aa\u14ab\u0001\u0000\u0000"+ + "\u0000\u14ab\u14ac\u0001\u0000\u0000\u0000\u14ac\u14ad\u0003\u01e0\u00f0"+ + "\u0000\u14ad\u14ae\u0005\u001b\u0000\u0000\u14ae\u14af\u0005\u02ff\u0000"+ + "\u0000\u14af\u14b4\u0003\u0210\u0108\u0000\u14b0\u14b1\u0005\u02f9\u0000"+ + "\u0000\u14b1\u14b3\u0003\u0210\u0108\u0000\u14b2\u14b0\u0001\u0000\u0000"+ + "\u0000\u14b3\u14b6\u0001\u0000\u0000\u0000\u14b4\u14b2\u0001\u0000\u0000"+ + "\u0000\u14b4\u14b5\u0001\u0000\u0000\u0000\u14b5\u14b7\u0001\u0000\u0000"+ + "\u0000\u14b6\u14b4\u0001\u0000\u0000\u0000\u14b7\u14b8\u0005\u0300\u0000"+ + "\u0000\u14b8\u14d2\u0001\u0000\u0000\u0000\u14b9\u14bb\u0005\u012e\u0000"+ + "\u0000\u14ba\u14b9\u0001\u0000\u0000\u0000\u14ba\u14bb\u0001\u0000\u0000"+ + "\u0000\u14bb\u14bc\u0001\u0000\u0000\u0000\u14bc\u14bd\u0005\u01ef\u0000"+ + "\u0000\u14bd\u14be\u0005\u00ec\u0000\u0000\u14be\u14bf\u0005\u02ff\u0000"+ + "\u0000\u14bf\u14c0\u0003\u01e0\u00f0\u0000\u14c0\u14cd\u0005\u0300\u0000"+ + "\u0000\u14c1\u14c2\u0005\u001b\u0000\u0000\u14c2\u14c3\u0005\u02ff\u0000"+ + "\u0000\u14c3\u14c8\u0003\u0210\u0108\u0000\u14c4\u14c5\u0005\u02f9\u0000"+ + "\u0000\u14c5\u14c7\u0003\u0210\u0108\u0000\u14c6\u14c4\u0001\u0000\u0000"+ + "\u0000\u14c7\u14ca\u0001\u0000\u0000\u0000\u14c8\u14c6\u0001\u0000\u0000"+ + "\u0000\u14c8\u14c9\u0001\u0000\u0000\u0000\u14c9\u14cb\u0001\u0000\u0000"+ + "\u0000\u14ca\u14c8\u0001\u0000\u0000\u0000\u14cb\u14cc\u0005\u0300\u0000"+ + "\u0000\u14cc\u14ce\u0001\u0000\u0000\u0000\u14cd\u14c1\u0001\u0000\u0000"+ + "\u0000\u14cd\u14ce\u0001\u0000\u0000\u0000\u14ce\u14cf\u0001\u0000\u0000"+ + "\u0000\u14cf\u14d0\u0005\u0300\u0000\u0000\u14d0\u14d2\u0001\u0000\u0000"+ + "\u0000\u14d1\u1467\u0001\u0000\u0000\u0000\u14d1\u1488\u0001\u0000\u0000"+ + "\u0000\u14d1\u149f\u0001\u0000\u0000\u0000\u14d1\u14aa\u0001\u0000\u0000"+ + "\u0000\u14d1\u14ba\u0001\u0000\u0000\u0000\u14d2\u14e4\u0001\u0000\u0000"+ + "\u0000\u14d3\u14d5\n\u0001\u0000\u0000\u14d4\u14d6\u0005\u0161\u0000\u0000"+ + "\u14d5\u14d4\u0001\u0000\u0000\u0000\u14d5\u14d6\u0001\u0000\u0000\u0000"+ + "\u14d6\u14d7\u0001\u0000\u0000\u0000\u14d7\u14d9\u0003\u01e8\u00f4\u0000"+ + "\u14d8\u14da\u0005\u02ff\u0000\u0000\u14d9\u14d8\u0001\u0000\u0000\u0000"+ + "\u14d9\u14da\u0001\u0000\u0000\u0000\u14da\u14db\u0001\u0000\u0000\u0000"+ + "\u14db\u14dd\u0003\u01e4\u00f2\u0000\u14dc\u14de\u0003\u01ea\u00f5\u0000"+ + "\u14dd\u14dc\u0001\u0000\u0000\u0000\u14dd\u14de\u0001\u0000\u0000\u0000"+ + "\u14de\u14e0\u0001\u0000\u0000\u0000\u14df\u14e1\u0005\u0300\u0000\u0000"+ + "\u14e0\u14df\u0001\u0000\u0000\u0000\u14e0\u14e1\u0001\u0000\u0000\u0000"+ + "\u14e1\u14e3\u0001\u0000\u0000\u0000\u14e2\u14d3\u0001\u0000\u0000\u0000"+ + "\u14e3\u14e6\u0001\u0000\u0000\u0000\u14e4\u14e2\u0001\u0000\u0000\u0000"+ + "\u14e4\u14e5\u0001\u0000\u0000\u0000\u14e5\u01e5\u0001\u0000\u0000\u0000"+ + "\u14e6\u14e4\u0001\u0000\u0000\u0000\u14e7\u14e9\u0005\u001b\u0000\u0000"+ + "\u14e8\u14e7\u0001\u0000\u0000\u0000\u14e8\u14e9\u0001\u0000\u0000\u0000"+ + "\u14e9\u14ea\u0001\u0000\u0000\u0000\u14ea\u14f3\u0003\u020c\u0106\u0000"+ + "\u14eb\u14f0\u0003\u020e\u0107\u0000\u14ec\u14ed\u0005\u02f9\u0000\u0000"+ + "\u14ed\u14ef\u0003\u020e\u0107\u0000\u14ee\u14ec\u0001\u0000\u0000\u0000"+ + "\u14ef\u14f2\u0001\u0000\u0000\u0000\u14f0\u14ee\u0001\u0000\u0000\u0000"+ + "\u14f0\u14f1\u0001\u0000\u0000\u0000\u14f1\u14f4\u0001\u0000\u0000\u0000"+ + "\u14f2\u14f0\u0001\u0000\u0000\u0000\u14f3\u14eb\u0001\u0000\u0000\u0000"+ + "\u14f3\u14f4\u0001\u0000\u0000\u0000\u14f4\u14fe\u0001\u0000\u0000\u0000"+ + "\u14f5\u14f7\u0005\u001b\u0000\u0000\u14f6\u14f5\u0001\u0000\u0000\u0000"+ + "\u14f6\u14f7\u0001\u0000\u0000\u0000\u14f7\u14f8\u0001\u0000\u0000\u0000"+ + "\u14f8\u14f9\u0003\u020c\u0106\u0000\u14f9\u14fa\u0005\u02ff\u0000\u0000"+ + "\u14fa\u14fb\u0003\u01ce\u00e7\u0000\u14fb\u14fc\u0005\u0300\u0000\u0000"+ + "\u14fc\u14fe\u0001\u0000\u0000\u0000\u14fd\u14e8\u0001\u0000\u0000\u0000"+ + "\u14fd\u14f6\u0001\u0000\u0000\u0000\u14fe\u01e7\u0001\u0000\u0000\u0000"+ + "\u14ff\u1501\u0005\u0112\u0000\u0000\u1500\u14ff\u0001\u0000\u0000\u0000"+ + "\u1500\u1501\u0001\u0000\u0000\u0000\u1501\u1502\u0001\u0000\u0000\u0000"+ + "\u1502\u1515\u0005\u0124\u0000\u0000\u1503\u1505\u0005\u0131\u0000\u0000"+ + "\u1504\u1506\u0005\u018d\u0000\u0000\u1505\u1504\u0001\u0000\u0000\u0000"+ + "\u1505\u1506\u0001\u0000\u0000\u0000\u1506\u1507\u0001\u0000\u0000\u0000"+ + "\u1507\u1515\u0005\u0124\u0000\u0000\u1508\u150a\u0005\u01e4\u0000\u0000"+ + "\u1509\u150b\u0005\u018d\u0000\u0000\u150a\u1509\u0001\u0000\u0000\u0000"+ + "\u150a\u150b\u0001\u0000\u0000\u0000\u150b\u150c\u0001\u0000\u0000\u0000"+ + "\u150c\u1515\u0005\u0124\u0000\u0000\u150d\u150f\u0005\u00ed\u0000\u0000"+ + "\u150e\u1510\u0005\u018d\u0000\u0000\u150f\u150e\u0001\u0000\u0000\u0000"+ + "\u150f\u1510\u0001\u0000\u0000\u0000\u1510\u1511\u0001\u0000\u0000\u0000"+ + "\u1511\u1515\u0005\u0124\u0000\u0000\u1512\u1513\u0005\u0081\u0000\u0000"+ + "\u1513\u1515\u0005\u0124\u0000\u0000\u1514\u1500\u0001\u0000\u0000\u0000"+ + "\u1514\u1503\u0001\u0000\u0000\u0000\u1514\u1508\u0001\u0000\u0000\u0000"+ + "\u1514\u150d\u0001\u0000\u0000\u0000\u1514\u1512\u0001\u0000\u0000\u0000"+ + "\u1515\u01e9\u0001\u0000\u0000\u0000\u1516\u1517\u0005\u0180\u0000\u0000"+ + "\u1517\u1525\u0003\u01ec\u00f6\u0000\u1518\u1519\u0005\u0272\u0000\u0000"+ + "\u1519\u151a\u0005\u02ff\u0000\u0000\u151a\u151f\u0003\u020a\u0105\u0000"+ + "\u151b\u151c\u0005\u02f9\u0000\u0000\u151c\u151e\u0003\u020a\u0105\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\u1522\u0001\u0000\u0000\u0000\u1521\u151f\u0001\u0000\u0000\u0000"+ + "\u1522\u1523\u0005\u0300\u0000\u0000\u1523\u1525\u0001\u0000\u0000\u0000"+ + "\u1524\u1516\u0001\u0000\u0000\u0000\u1524\u1518\u0001\u0000\u0000\u0000"+ + "\u1525\u01eb\u0001\u0000\u0000\u0000\u1526\u1527\u0006\u00f6\uffff\uffff"+ + "\u0000\u1527\u1533\u0003\u01b0\u00d8\u0000\u1528\u1529\u0003\u01b0\u00d8"+ + "\u0000\u1529\u152a\u0003\u01c8\u00e4\u0000\u152a\u152b\u0003\u01b0\u00d8"+ + "\u0000\u152b\u1533\u0001\u0000\u0000\u0000\u152c\u152d\u0005\u02ff\u0000"+ + "\u0000\u152d\u152e\u0003\u01ec\u00f6\u0000\u152e\u152f\u0005\u0300\u0000"+ + "\u0000\u152f\u1533\u0001\u0000\u0000\u0000\u1530\u1531\u0005\u016d\u0000"+ + "\u0000\u1531\u1533\u0003\u01ec\u00f6\u0001\u1532\u1526\u0001\u0000\u0000"+ + "\u0000\u1532\u1528\u0001\u0000\u0000\u0000\u1532\u152c\u0001\u0000\u0000"+ + "\u0000\u1532\u1530\u0001\u0000\u0000\u0000\u1533\u153c\u0001\u0000\u0000"+ + "\u0000\u1534\u1535\n\u0003\u0000\u0000\u1535\u1536\u0005\u0017\u0000\u0000"+ + "\u1536\u153b\u0003\u01ec\u00f6\u0004\u1537\u1538\n\u0002\u0000\u0000\u1538"+ + "\u1539\u0005\u0187\u0000\u0000\u1539\u153b\u0003\u01ec\u00f6\u0003\u153a"+ + "\u1534\u0001\u0000\u0000\u0000\u153a\u1537\u0001\u0000\u0000\u0000\u153b"+ + "\u153e\u0001\u0000\u0000\u0000\u153c\u153a\u0001\u0000\u0000\u0000\u153c"+ + "\u153d\u0001\u0000\u0000\u0000\u153d\u01ed\u0001\u0000\u0000\u0000\u153e"+ + "\u153c\u0001\u0000\u0000\u0000\u153f\u155a\u0005\u02fe\u0000\u0000\u1540"+ + "\u1542\u0007\u0006\u0000\u0000\u1541\u1540\u0001\u0000\u0000\u0000\u1541"+ + "\u1542\u0001\u0000\u0000\u0000\u1542\u1544\u0001\u0000\u0000\u0000\u1543"+ + "\u1545\u0003\u0202\u0101\u0000\u1544\u1543\u0001\u0000\u0000\u0000\u1544"+ + "\u1545\u0001\u0000\u0000\u0000\u1545\u1546\u0001\u0000\u0000\u0000\u1546"+ + "\u155a\u0003\u01da\u00ed\u0000\u1547\u1549\u0007\u0006\u0000\u0000\u1548"+ + "\u1547\u0001\u0000\u0000\u0000\u1548\u1549\u0001\u0000\u0000\u0000\u1549"+ + "\u154b\u0001\u0000\u0000\u0000\u154a\u154c\u0003\u0202\u0101\u0000\u154b"+ + "\u154a\u0001\u0000\u0000\u0000\u154b\u154c\u0001\u0000\u0000\u0000\u154c"+ + "\u154d\u0001\u0000\u0000\u0000\u154d\u154e\u0003\u01da\u00ed\u0000\u154e"+ + "\u154f\u0001\u0000\u0000\u0000\u154f\u1550\u0005\u0188\u0000\u0000\u1550"+ + "\u1552\u00056\u0000\u0000\u1551\u1553\u0007\u0006\u0000\u0000\u1552\u1551"+ + "\u0001\u0000\u0000\u0000\u1552\u1553\u0001\u0000\u0000\u0000\u1553\u1555"+ + "\u0001\u0000\u0000\u0000\u1554\u1556\u0003\u0202\u0101\u0000\u1555\u1554"+ + "\u0001\u0000\u0000\u0000\u1555\u1556\u0001\u0000\u0000\u0000\u1556\u1557"+ + "\u0001\u0000\u0000\u0000\u1557\u1558\u0003\u01da\u00ed\u0000\u1558\u155a"+ + "\u0001\u0000\u0000\u0000\u1559\u153f\u0001\u0000\u0000\u0000\u1559\u1541"+ + "\u0001\u0000\u0000\u0000\u1559\u1548\u0001\u0000\u0000\u0000\u155a\u01ef"+ + "\u0001\u0000\u0000\u0000\u155b\u155c\u0005\u016d\u0000\u0000\u155c\u155d"+ + "\u0005\u0172\u0000\u0000\u155d\u01f1\u0001\u0000\u0000\u0000\u155e\u1560"+ + "\u0003\u01f0\u00f8\u0000\u155f\u155e\u0001\u0000\u0000\u0000\u1560\u1561"+ + "\u0001\u0000\u0000\u0000\u1561\u155f\u0001\u0000\u0000\u0000\u1561\u1562"+ + "\u0001\u0000\u0000\u0000\u1562\u01f3\u0001\u0000\u0000\u0000\u1563\u1564"+ + "\u0005\u0287\u0000\u0000\u1564\u1565\u0005\u02ff\u0000\u0000\u1565\u1566"+ + "\u0003\u01d4\u00ea\u0000\u1566\u1567\u0005\u0300\u0000\u0000\u1567\u1569"+ + "\u0001\u0000\u0000\u0000\u1568\u1563\u0001\u0000\u0000\u0000\u1568\u1569"+ + "\u0001\u0000\u0000\u0000\u1569\u156e\u0001\u0000\u0000\u0000\u156a\u156b"+ + "\u0005\u0272\u0000\u0000\u156b\u156c\u0005\u010c\u0000\u0000\u156c\u156d"+ + "\u0005\u023a\u0000\u0000\u156d\u156f\u0003\u0202\u0101\u0000\u156e\u156a"+ + "\u0001\u0000\u0000\u0000\u156e\u156f\u0001\u0000\u0000\u0000\u156f\u01f5"+ + "\u0001\u0000\u0000\u0000\u1570\u1576\u0003\u0202\u0101\u0000\u1571\u1572"+ + "\u0005\u02ff\u0000\u0000\u1572\u1573\u0003\u01b0\u00d8\u0000\u1573\u1574"+ + "\u0005\u0300\u0000\u0000\u1574\u1576\u0001\u0000\u0000\u0000\u1575\u1570"+ + "\u0001\u0000\u0000\u0000\u1575\u1571\u0001\u0000\u0000\u0000\u1576\u1578"+ + "\u0001\u0000\u0000\u0000\u1577\u1579\u0003\u0202\u0101\u0000\u1578\u1577"+ + "\u0001\u0000\u0000\u0000\u1578\u1579\u0001\u0000\u0000\u0000\u1579\u157b"+ + "\u0001\u0000\u0000\u0000\u157a\u157c\u00070\u0000\u0000\u157b\u157a\u0001"+ + "\u0000\u0000\u0000\u157b\u157c\u0001\u0000\u0000\u0000\u157c\u157f\u0001"+ + "\u0000\u0000\u0000\u157d\u157e\u0005\u0175\u0000\u0000\u157e\u1580\u0007"+ + " \u0000\u0000\u157f\u157d\u0001\u0000\u0000\u0000\u157f\u1580\u0001\u0000"+ + "\u0000\u0000\u1580\u01f7\u0001\u0000\u0000\u0000\u1581\u1582\u0005m\u0000"+ + "\u0000\u1582\u1584\u0003\u01cc\u00e6\u0000\u1583\u1581\u0001\u0000\u0000"+ + "\u0000\u1583\u1584\u0001\u0000\u0000\u0000\u1584\u15c6\u0001\u0000\u0000"+ + "\u0000\u1585\u1586\u0005N\u0000\u0000\u1586\u1587\u0005\u02ff\u0000\u0000"+ + "\u1587\u1588\u0003\u01b0\u00d8\u0000\u1588\u158b\u0005\u0300\u0000\u0000"+ + "\u1589\u158a\u0005\u0167\u0000\u0000\u158a\u158c\u0005\u0294\u0000\u0000"+ + "\u158b\u1589\u0001\u0000\u0000\u0000\u158b\u158c\u0001\u0000\u0000\u0000"+ + "\u158c\u15c7\u0001\u0000\u0000\u0000\u158d\u158e\u0005\u0263\u0000\u0000"+ + "\u158e\u158f\u0005\u02ff\u0000\u0000\u158f\u1590\u0003\u01d0\u00e8\u0000"+ + "\u1590\u1591\u0005\u0300\u0000\u0000\u1591\u15c7\u0001\u0000\u0000\u0000"+ + "\u1592\u1593\u0005\u01b4\u0000\u0000\u1593\u1594\u0005\u0126\u0000\u0000"+ + "\u1594\u1595\u0005\u02ff\u0000\u0000\u1595\u1596\u0003\u01d0\u00e8\u0000"+ + "\u1596\u1597\u0005\u0300\u0000\u0000\u1597\u1598\u0003\u01f4\u00fa\u0000"+ + "\u1598\u15c7\u0001\u0000\u0000\u0000\u1599\u159c\u0005\u00cd\u0000\u0000"+ + "\u159a\u159b\u0005\u0272\u0000\u0000\u159b\u159d\u0003\u01dc\u00ee\u0000"+ + "\u159c\u159a\u0001\u0000\u0000\u0000\u159c\u159d\u0001\u0000\u0000\u0000"+ + "\u159d\u159e\u0001\u0000\u0000\u0000\u159e\u159f\u0005\u02ff\u0000\u0000"+ + "\u159f\u15a0\u0003\u01f6\u00fb\u0000\u15a0\u15a1\u0005\u0287\u0000\u0000"+ + "\u15a1\u15a2\u0003\u01d0\u00e8\u0000\u15a2\u15a3\u0005\u0300\u0000\u0000"+ + "\u15a3\u15a4\u0003\u01f4\u00fa\u0000\u15a4\u15a5\u0005\u0284\u0000\u0000"+ + "\u15a5\u15a6\u0005\u02ff\u0000\u0000\u15a6\u15a7\u0003\u01ec\u00f6\u0000"+ + "\u15a7\u15a8\u0005\u0300\u0000\u0000\u15a8\u15aa\u0001\u0000\u0000\u0000"+ + "\u15a9\u1599\u0001\u0000\u0000\u0000\u15a9\u15aa\u0001\u0000\u0000\u0000"+ + "\u15aa\u15c7\u0001\u0000\u0000\u0000\u15ab\u15ac\u0005\u00e5\u0000\u0000"+ + "\u15ac\u15ad\u0005\u0126\u0000\u0000\u15ad\u15ae\u0005\u02ff\u0000\u0000"+ + "\u15ae\u15af\u0003\u01d0\u00e8\u0000\u15af\u15b0\u0005\u0300\u0000\u0000"+ + "\u15b0\u15b1\u0005\u01c5\u0000\u0000\u15b1\u15b3\u0003\u0202\u0101\u0000"+ + "\u15b2\u15b4\u0003\u01d0\u00e8\u0000\u15b3\u15b2\u0001\u0000\u0000\u0000"+ + "\u15b3\u15b4\u0001\u0000\u0000\u0000\u15b4\u15ba\u0001\u0000\u0000\u0000"+ + "\u15b5\u15b6\u0005\u0146\u0000\u0000\u15b6\u15bb\u0005\u00ed\u0000\u0000"+ + "\u15b7\u15b8\u0005\u0146\u0000\u0000\u15b8\u15bb\u0005\u019e\u0000\u0000"+ + "\u15b9\u15bb\u0005\u0147\u0000\u0000\u15ba\u15b5\u0001\u0000\u0000\u0000"+ + "\u15ba\u15b7\u0001\u0000\u0000\u0000\u15ba\u15b9\u0001\u0000\u0000\u0000"+ + "\u15ba\u15bb\u0001\u0000\u0000\u0000\u15bb\u15bf\u0001\u0000\u0000\u0000"+ + "\u15bc\u15bd\u0005\u0180\u0000\u0000\u15bd\u15be\u0005\u00a3\u0000\u0000"+ + "\u15be\u15c0\u0003\u0202\u0101\u0000\u15bf\u15bc\u0001\u0000\u0000\u0000"+ + "\u15bf\u15c0\u0001\u0000\u0000\u0000\u15c0\u15c4\u0001\u0000\u0000\u0000"+ + "\u15c1\u15c2\u0005\u0180\u0000\u0000\u15c2\u15c3\u0005\u026a\u0000\u0000"+ + "\u15c3\u15c5\u0003\u0202\u0101\u0000\u15c4\u15c1\u0001\u0000\u0000\u0000"+ + "\u15c4\u15c5\u0001\u0000\u0000\u0000\u15c5\u15c7\u0001\u0000\u0000\u0000"+ + "\u15c6\u1585\u0001\u0000\u0000\u0000\u15c6\u158d\u0001\u0000\u0000\u0000"+ + "\u15c6\u1592\u0001\u0000\u0000\u0000\u15c6\u15a9\u0001\u0000\u0000\u0000"+ + "\u15c6\u15ab\u0001\u0000\u0000\u0000\u15c7\u15cc\u0001\u0000\u0000\u0000"+ + "\u15c8\u15ca\u0005\u016d\u0000\u0000\u15c9\u15c8\u0001\u0000\u0000\u0000"+ + "\u15c9\u15ca\u0001\u0000\u0000\u0000\u15ca\u15cb\u0001\u0000\u0000\u0000"+ + "\u15cb\u15cd\u0005\u009d\u0000\u0000\u15cc\u15c9\u0001\u0000\u0000\u0000"+ + "\u15cc\u15cd\u0001\u0000\u0000\u0000\u15cd\u15d0\u0001\u0000\u0000\u0000"+ + "\u15ce\u15cf\u0005\u0111\u0000\u0000\u15cf\u15d1\u0007\u0017\u0000\u0000"+ + "\u15d0\u15ce\u0001\u0000\u0000\u0000\u15d0\u15d1\u0001\u0000\u0000\u0000"+ + "\u15d1\u01f9\u0001\u0000\u0000\u0000\u15d2\u15d7\u0003\u01cc\u00e6\u0000"+ + "\u15d3\u15d7\u0005\u008d\u0000\u0000\u15d4\u15d7\u0005\u0206\u0000\u0000"+ + "\u15d5\u15d7\u0005\u01b9\u0000\u0000\u15d6\u15d2\u0001\u0000\u0000\u0000"+ + "\u15d6\u15d3\u0001\u0000\u0000\u0000\u15d6\u15d4\u0001\u0000\u0000\u0000"+ + "\u15d6\u15d5\u0001\u0000\u0000\u0000\u15d7\u01fb\u0001\u0000\u0000\u0000"+ + "\u15d8\u15dd\u0003\u01fa\u00fd\u0000\u15d9\u15da\u0005\u02f9\u0000\u0000"+ + "\u15da\u15dc\u0003\u01fa\u00fd\u0000\u15db\u15d9\u0001\u0000\u0000\u0000"+ + "\u15dc\u15df\u0001\u0000\u0000\u0000\u15dd\u15db\u0001\u0000\u0000\u0000"+ + "\u15dd\u15de\u0001\u0000\u0000\u0000\u15de\u01fd\u0001\u0000\u0000\u0000"+ + "\u15df\u15dd\u0001\u0000\u0000\u0000\u15e0\u15ec\u0005\u0180\u0000\u0000"+ + "\u15e1\u15ec\u0005\u017c\u0000\u0000\u15e2\u15ec\u0005\u0259\u0000\u0000"+ + "\u15e3\u15ec\u0005\u00da\u0000\u0000\u15e4\u15ec\u0005\u028e\u0000\u0000"+ + "\u15e5\u15ec\u0005\u0167\u0000\u0000\u15e6\u15ec\u0005\u016a\u0000\u0000"+ + "\u15e7\u15ec\u0005\u0309\u0000\u0000\u15e8\u15ec\u0005\u0305\u0000\u0000"+ + "\u15e9\u15ec\u0005\u0306\u0000\u0000\u15ea\u15ec\u0003\u0202\u0101\u0000"+ + "\u15eb\u15e0\u0001\u0000\u0000\u0000\u15eb\u15e1\u0001\u0000\u0000\u0000"+ + "\u15eb\u15e2\u0001\u0000\u0000\u0000\u15eb\u15e3\u0001\u0000\u0000\u0000"+ + "\u15eb\u15e4\u0001\u0000\u0000\u0000\u15eb\u15e5\u0001\u0000\u0000\u0000"+ + "\u15eb\u15e6\u0001\u0000\u0000\u0000\u15eb\u15e7\u0001\u0000\u0000\u0000"+ + "\u15eb\u15e8\u0001\u0000\u0000\u0000\u15eb\u15e9\u0001\u0000\u0000\u0000"+ + "\u15eb\u15ea\u0001\u0000\u0000\u0000\u15ec\u01ff\u0001\u0000\u0000\u0000"+ + "\u15ed\u15ee\u00071\u0000\u0000\u15ee\u0201\u0001\u0000\u0000\u0000\u15ef"+ + "\u15f0\u0006\u0101\uffff\uffff\u0000\u15f0\u15f6\u0003\u0200\u0100\u0000"+ + "\u15f1\u15f6\u0005\u030a\u0000\u0000\u15f2\u15f6\u0005\u030b\u0000\u0000"+ + "\u15f3\u15f6\u0003\u01c4\u00e2\u0000\u15f4\u15f6\u0005\u030d\u0000\u0000"+ + "\u15f5\u15ef\u0001\u0000\u0000\u0000\u15f5\u15f1\u0001\u0000\u0000\u0000"+ + "\u15f5\u15f2\u0001\u0000\u0000\u0000\u15f5\u15f3\u0001\u0000\u0000\u0000"+ + "\u15f5\u15f4\u0001\u0000\u0000\u0000\u15f6\u15fc\u0001\u0000\u0000\u0000"+ + "\u15f7\u15f8\n\u0003\u0000\u0000\u15f8\u15f9\u0005\u0308\u0000\u0000\u15f9"+ + "\u15fb\u0003\u0202\u0101\u0004\u15fa\u15f7\u0001\u0000\u0000\u0000\u15fb"+ + "\u15fe\u0001\u0000\u0000\u0000\u15fc\u15fa\u0001\u0000\u0000\u0000\u15fc"+ + "\u15fd\u0001\u0000\u0000\u0000\u15fd\u0203\u0001\u0000\u0000\u0000\u15fe"+ + "\u15fc\u0001\u0000\u0000\u0000\u15ff\u1600\t\u0000\u0000\u0000\u1600\u0205"+ + "\u0001\u0000\u0000\u0000\u1601\u1602\u0003\u0202\u0101\u0000\u1602\u0207"+ + "\u0001\u0000\u0000\u0000\u1603\u1604\u0003\u0202\u0101\u0000\u1604\u0209"+ + "\u0001\u0000\u0000\u0000\u1605\u1606\u0003\u0202\u0101\u0000\u1606\u020b"+ + "\u0001\u0000\u0000\u0000\u1607\u1608\u0003\u0202\u0101\u0000\u1608\u020d"+ + "\u0001\u0000\u0000\u0000\u1609\u160a\u0003\u0202\u0101\u0000\u160a\u020f"+ + "\u0001\u0000\u0000\u0000\u160b\u160c\u0003\u0202\u0101\u0000\u160c\u0211"+ + "\u0001\u0000\u0000\u0000\u160d\u160e\u0003\u0202\u0101\u0000\u160e\u0213"+ + "\u0001\u0000\u0000\u0000\u02b5\u0219\u021d\u0255\u0281\u02a1\u02be\u02d5"+ + "\u02e3\u02f3\u02fc\u0300\u0327\u0335\u0340\u034a\u0352\u035b\u0361\u0367"+ + "\u036a\u036e\u0372\u0376\u037a\u037f\u0385\u0389\u0392\u039a\u03a3\u03ac"+ + "\u03b6\u03c0\u03c9\u03ce\u03d4\u03dd\u03e1\u03e8\u03ef\u0409\u040b\u0412"+ + "\u041a\u041d\u0421\u042a\u042d\u0431\u0435\u0440\u044c\u0453\u046c\u0472"+ + "\u047d\u0490\u049c\u04ac\u04b2\u04b4\u04b8\u04c2\u04cb\u04cd\u04d8\u04f3"+ + "\u04ff\u0513\u0517\u051c\u051e\u0526\u0530\u053a\u0554\u0568\u056f\u0575"+ + "\u057a\u0587\u058c\u0593\u0599\u059e\u05a9\u05ae\u05b6\u05bb\u05bf\u05d9"+ + "\u05db\u05e1\u05e6\u05ea\u05ee\u05f2\u05f6\u0600\u0607\u0617\u0621\u0631"+ + "\u0644\u0650\u0672\u0682\u0695\u06a7\u06e4\u0704\u071c\u0731\u0747\u074e"+ + "\u0783\u0793\u0796\u07a6\u07ac\u07b0\u07b6\u07bc\u07c2\u07c8\u07ce\u07d4"+ + "\u07da\u07e0\u07e6\u07ea\u07f0\u07f6\u07fc\u0805\u0808\u080b\u0810\u0813"+ + "\u0823\u0829\u082d\u0833\u0839\u083d\u0854\u085a\u085e\u0864\u086a\u0870"+ + "\u0876\u087c\u0882\u0888\u088e\u0894\u0898\u089e\u08a4\u08a8\u08b8\u08be"+ + "\u08c4\u08d8\u08df\u08e7\u08f3\u08f9\u08fd\u090c\u0911\u0916\u091b\u0920"+ + "\u0925\u092a\u092f\u0935\u093a\u093e\u0948\u094e\u0956\u0958\u0963\u096b"+ + "\u0976\u0984\u0990\u0992\u0999\u09a0\u09a8\u09b3\u09b7\u09bc\u09c5\u09ca"+ + "\u09d3\u09e2\u09f7\u09f9\u09fb\u09ff\u0a03\u0a08\u0a0b\u0a11\u0a15\u0a19"+ + "\u0a1e\u0a21\u0a28\u0a2b\u0a2e\u0a36\u0a3a\u0a3c\u0a44\u0a4b\u0a4e\u0a52"+ + "\u0a58\u0a5b\u0a68\u0a6e\u0a74\u0a7a\u0a80\u0a86\u0a8a\u0a8e\u0a9b\u0aa3"+ + "\u0aa7\u0ab0\u0ab7\u0ac0\u0ac8\u0ad9\u0add\u0ae4\u0aec\u0af2\u0b06\u0b1b"+ + "\u0b1d\u0b1f\u0b26\u0b31\u0b35\u0b39\u0b40\u0b43\u0b4a\u0b54\u0b5d\u0b61"+ + "\u0b67\u0b6c\u0b6f\u0b75\u0b7b\u0b7f\u0b82\u0b86\u0b89\u0b8c\u0b95\u0b97"+ + "\u0bba\u0bbd\u0bc0\u0bc8\u0bcf\u0bd4\u0bd8\u0bdc\u0be3\u0be8\u0bec\u0bef"+ + "\u0bf2\u0bf6\u0bfd\u0c00\u0c2e\u0c35\u0c39\u0c3f\u0c4a\u0c52\u0c58\u0c5c"+ + "\u0c62\u0c66\u0c6c\u0c74\u0c78\u0c7f\u0c83\u0c89\u0c8d\u0c95\u0c99\u0ca0"+ + "\u0ca4\u0caa\u0cae\u0cb4\u0cbb\u0cbf\u0cc3\u0cc7\u0ccc\u0cd0\u0cd7\u0cdb"+ + "\u0ce4\u0cea\u0cf1\u0cf7\u0cfe\u0d04\u0d0a\u0d10\u0d14\u0d1a\u0d22\u0d28"+ + "\u0d2e\u0d32\u0d38\u0d3c\u0d42\u0d46\u0d4c\u0d54\u0d58\u0d5e\u0d62\u0d68"+ + "\u0d72\u0d76\u0d7e\u0d82\u0d8a\u0d8e\u0d96\u0d9a\u0da0\u0dac\u0db2\u0db8"+ + "\u0dbc\u0dc2\u0dcb\u0dd3\u0ddc\u0de0\u0de5\u0de9\u0dec\u0df5\u0dfa\u0e05"+ + "\u0e0e\u0e15\u0e1b\u0e1f\u0e22\u0e28\u0e30\u0e35\u0e38\u0e41\u0e43\u0e45"+ + "\u0e48\u0e51\u0e54\u0e58\u0e6b\u0e6e\u0e71\u0e80\u0e84\u0e86\u0e89\u0e8b"+ + "\u0e93\u0e9b\u0ea3\u0eaf\u0eb5\u0eb9\u0ec0\u0ec8\u0ecf\u0ed6\u0edc\u0ee4"+ + "\u0ee8\u0ef3\u0f18\u0f2c\u0f32\u0f37\u0f3b\u0f3f\u0f44\u0f4a\u0f4e\u0f51"+ + "\u0f54\u0f57\u0f5a\u0f5d\u0f60\u0f63\u0f66\u0f69\u0f6c\u0f6f\u0f75\u0f78"+ + "\u0f7c\u0f80\u0f84\u0f89\u0f8f\u0f93\u0f96\u0f99\u0f9c\u0f9f\u0fa2\u0fa5"+ + "\u0fa8\u0fab\u0fae\u0fb1\u0fb5\u0fbc\u0fc4\u0fcd\u0fd3\u0fd9\u0fdd\u0fe4"+ + "\u0fe6\u0fec\u0ff2\u0ff7\u0ffb\u1008\u100f\u1012\u1019\u1029\u1030\u1034"+ + "\u1037\u103b\u103f\u1042\u1046\u1049\u104e\u1051\u1055\u1059\u105c\u105f"+ + "\u1064\u106b\u106e\u1077\u107f\u1086\u108a\u108d\u1090\u1093\u1097\u109a"+ + "\u109d\u10a5\u10a7\u10a9\u10ac\u10b3\u10b9\u10bd\u10c0\u10c3\u10c6\u10c9"+ + "\u10cc\u10d2\u10d4\u10de\u10eb\u10f6\u10fb\u10ff\u1107\u110f\u111a\u111f"+ + "\u1122\u1125\u112a\u112d\u1130\u1134\u1139\u113d\u1149\u1157\u1161\u1165"+ + "\u1170\u1175\u117a\u117f\u1183\u118c\u1191\u1197\u11a1\u11a4\u11aa\u11af"+ + "\u11b4\u11c1\u11c9\u11cc\u11d1\u11d3\u11db\u11e5\u11e7\u11fe\u1206\u1237"+ + "\u1249\u124e\u125e\u1270\u1275\u1279\u127e\u1285\u1292\u129a\u129c\u12a7"+ + "\u12a9\u12b0\u12b8\u12ba\u12c6\u12ca\u12d6\u12da\u12de\u12e6\u12ec\u12f3"+ + "\u12f7\u12fa\u12fd\u1300\u1307\u130f\u1316\u1321\u1327\u1331\u1337\u133d"+ + "\u1348\u1356\u1359\u1368\u137a\u137f\u1385\u138a\u1390\u1396\u13a0\u13a6"+ + "\u13a9\u13b1\u13b6\u13bd\u13c1\u13ca\u13d6\u13df\u13e2\u13f0\u13f2\u13f6"+ + "\u13fd\u1405\u140b\u1412\u1419\u141d\u1422\u142a\u142f\u1440\u1446\u1448"+ + "\u1453\u1457\u1460\u1463\u1469\u146d\u1470\u147a\u1483\u1485\u1488\u148e"+ + "\u1497\u149c\u149f\u14a4\u14a7\u14aa\u14b4\u14ba\u14c8\u14cd\u14d1\u14d5"+ + "\u14d9\u14dd\u14e0\u14e4\u14e8\u14f0\u14f3\u14f6\u14fd\u1500\u1505\u150a"+ + "\u150f\u1514\u151f\u1524\u1532\u153a\u153c\u1541\u1544\u1548\u154b\u1552"+ + "\u1555\u1559\u1561\u1568\u156e\u1575\u1578\u157b\u157f\u1583\u158b\u159c"+ + "\u15a9\u15b3\u15ba\u15bf\u15c4\u15c6\u15c9\u15cc\u15d0\u15d6\u15dd\u15eb"+ + "\u15f5\u15fc"; + public static final String _serializedATN = Utils.join( + new String[] { + _serializedATNSegment0, + _serializedATNSegment1, + _serializedATNSegment2 + }, + "" + ); + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ 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 new file mode 100644 index 000000000..ff4d45716 --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserBaseListener.java @@ -0,0 +1,3232 @@ +// 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; + +/** + * This class provides an empty implementation of {@link PostgreSqlParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +@SuppressWarnings("CheckReturnValue") +public class PostgreSqlParserBaseListener implements PostgreSqlParserListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void enterStmt(PostgreSqlParser.StmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStmt(PostgreSqlParser.StmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void exitSelect_into_stmt(PostgreSqlParser.Select_into_stmtContext 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 enterWith_expr(PostgreSqlParser.With_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void enterTransaction_mode_list(PostgreSqlParser.Transaction_mode_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTransaction_mode_list(PostgreSqlParser.Transaction_mode_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

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

The default implementation does nothing.

+ */ + @Override public void exitVacuum_opt(PostgreSqlParser.Vacuum_optContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterValues_stmt(PostgreSqlParser.Values_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitValues_stmt(PostgreSqlParser.Values_stmtContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSelector_clause(PostgreSqlParser.Selector_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSelector_clause(PostgreSqlParser.Selector_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrom_clause(PostgreSqlParser.From_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrom_clause(PostgreSqlParser.From_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWhere_clause(PostgreSqlParser.Where_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWhere_clause(PostgreSqlParser.Where_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterHaving_clause(PostgreSqlParser.Having_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitHaving_clause(PostgreSqlParser.Having_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumn_list(PostgreSqlParser.Column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumn_list(PostgreSqlParser.Column_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrame(PostgreSqlParser.FrameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrame(PostgreSqlParser.FrameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrame_start(PostgreSqlParser.Frame_startContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrame_start(PostgreSqlParser.Frame_startContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrame_end(PostgreSqlParser.Frame_endContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrame_end(PostgreSqlParser.Frame_endContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFrame_clause(PostgreSqlParser.Frame_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFrame_clause(PostgreSqlParser.Frame_clauseContext 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 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 enterCombine_clause(PostgreSqlParser.Combine_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCombine_clause(PostgreSqlParser.Combine_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLimit_clause(PostgreSqlParser.Limit_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLimit_clause(PostgreSqlParser.Limit_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOffset_clause(PostgreSqlParser.Offset_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOffset_clause(PostgreSqlParser.Offset_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFor_clause(PostgreSqlParser.For_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFor_clause(PostgreSqlParser.For_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterUpdater_expr(PostgreSqlParser.Updater_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitUpdater_expr(PostgreSqlParser.Updater_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 enterExpr(PostgreSqlParser.ExprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpr(PostgreSqlParser.ExprContext 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} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBool_expr(PostgreSqlParser.Bool_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBool_expr(PostgreSqlParser.Bool_exprContext 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 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 enterExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_sig(PostgreSqlParser.Func_sigContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_sig(PostgreSqlParser.Func_sigContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterType_name(PostgreSqlParser.Type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitType_name(PostgreSqlParser.Type_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTimezone(PostgreSqlParser.TimezoneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTimezone(PostgreSqlParser.TimezoneContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOper(PostgreSqlParser.OperContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOper(PostgreSqlParser.OperContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggregate(PostgreSqlParser.AggregateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggregate(PostgreSqlParser.AggregateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterName_(PostgreSqlParser.Name_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitName_(PostgreSqlParser.Name_Context 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 enterIdentifier_list(PostgreSqlParser.Identifier_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIdentifier_list(PostgreSqlParser.Identifier_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOption_expr(PostgreSqlParser.Option_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOption_expr(PostgreSqlParser.Option_exprContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterOption_list(PostgreSqlParser.Option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitOption_list(PostgreSqlParser.Option_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTable_name_(PostgreSqlParser.Table_name_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTable_name_(PostgreSqlParser.Table_name_Context ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterData_type(PostgreSqlParser.Data_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitData_type(PostgreSqlParser.Data_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterData_type_list(PostgreSqlParser.Data_type_listContext 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) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJoin_type(PostgreSqlParser.Join_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJoin_type(PostgreSqlParser.Join_typeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterJoin_clause(PostgreSqlParser.Join_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitJoin_clause(PostgreSqlParser.Join_clauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPredicate(PostgreSqlParser.PredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPredicate(PostgreSqlParser.PredicateContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumn_constraint(PostgreSqlParser.Column_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumn_constraint(PostgreSqlParser.Column_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIndex_parameters(PostgreSqlParser.Index_parametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIndex_parameters(PostgreSqlParser.Index_parametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExclude_element(PostgreSqlParser.Exclude_elementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExclude_element(PostgreSqlParser.Exclude_elementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTable_constraint(PostgreSqlParser.Table_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTable_constraint(PostgreSqlParser.Table_constraintContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRole_name(PostgreSqlParser.Role_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRole_name(PostgreSqlParser.Role_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterRole_name_list(PostgreSqlParser.Role_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitRole_name_list(PostgreSqlParser.Role_name_listContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParam_value(PostgreSqlParser.Param_valueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParam_value(PostgreSqlParser.Param_valueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIdentifier(PostgreSqlParser.IdentifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIdentifier(PostgreSqlParser.IdentifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTodo_implement(PostgreSqlParser.Todo_implementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTodo_implement(PostgreSqlParser.Todo_implementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumn_name(PostgreSqlParser.Column_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumn_name(PostgreSqlParser.Column_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAlias(PostgreSqlParser.AliasContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAlias(PostgreSqlParser.AliasContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumn_alias(PostgreSqlParser.Column_aliasContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumn_alias(PostgreSqlParser.Column_aliasContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterColumn_definition(PostgreSqlParser.Column_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitColumn_definition(PostgreSqlParser.Column_definitionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterWindow_name(PostgreSqlParser.Window_nameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitWindow_name(PostgreSqlParser.Window_nameContext ctx) { } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitTerminal(TerminalNode node) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitErrorNode(ErrorNode node) { } +} \ No newline at end of file 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 new file mode 100644 index 000000000..64823a0aa --- /dev/null +++ b/headless-services/commons/jpql/src/main/java/org/springframework/ide/vscode/parser/postgresql/PostgreSqlParserListener.java @@ -0,0 +1,2670 @@ +// Generated from PostgreSqlParser.g4 by ANTLR 4.13.1 +package org.springframework.ide.vscode.parser.postgresql; +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link PostgreSqlParser}. + */ +public interface PostgreSqlParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link PostgreSqlParser#root}. + * @param ctx the parse tree + */ + void enterRoot(PostgreSqlParser.RootContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#root}. + * @param ctx the parse tree + */ + void exitRoot(PostgreSqlParser.RootContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#stmt}. + * @param ctx the parse tree + */ + void enterStmt(PostgreSqlParser.StmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#stmt}. + * @param ctx the parse tree + */ + void exitStmt(PostgreSqlParser.StmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#abort_stmt}. + * @param ctx the parse tree + */ + void enterAbort_stmt(PostgreSqlParser.Abort_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#abort_stmt}. + * @param ctx the parse tree + */ + void exitAbort_stmt(PostgreSqlParser.Abort_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_stmt}. + * @param ctx the parse tree + */ + void enterAlter_stmt(PostgreSqlParser.Alter_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_stmt}. + * @param ctx the parse tree + */ + void exitAlter_stmt(PostgreSqlParser.Alter_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_aggregate_stmt}. + * @param ctx the parse tree + */ + void enterAlter_aggregate_stmt(PostgreSqlParser.Alter_aggregate_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_aggregate_stmt}. + * @param ctx the parse tree + */ + void exitAlter_aggregate_stmt(PostgreSqlParser.Alter_aggregate_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_collation_stmt}. + * @param ctx the parse tree + */ + void enterAlter_collation_stmt(PostgreSqlParser.Alter_collation_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_collation_stmt}. + * @param ctx the parse tree + */ + void exitAlter_collation_stmt(PostgreSqlParser.Alter_collation_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_conversion_stmt}. + * @param ctx the parse tree + */ + void enterAlter_conversion_stmt(PostgreSqlParser.Alter_conversion_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_conversion_stmt}. + * @param ctx the parse tree + */ + void exitAlter_conversion_stmt(PostgreSqlParser.Alter_conversion_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_database_stmt}. + * @param ctx the parse tree + */ + void enterAlter_database_stmt(PostgreSqlParser.Alter_database_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_database_stmt}. + * @param ctx the parse tree + */ + void exitAlter_database_stmt(PostgreSqlParser.Alter_database_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_default_privileges_stmt}. + * @param ctx the parse tree + */ + void enterAlter_default_privileges_stmt(PostgreSqlParser.Alter_default_privileges_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_default_privileges_stmt}. + * @param ctx the parse tree + */ + void exitAlter_default_privileges_stmt(PostgreSqlParser.Alter_default_privileges_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_domain_stmt}. + * @param ctx the parse tree + */ + void enterAlter_domain_stmt(PostgreSqlParser.Alter_domain_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_domain_stmt}. + * @param ctx the parse tree + */ + void exitAlter_domain_stmt(PostgreSqlParser.Alter_domain_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_event_trigger_stmt}. + * @param ctx the parse tree + */ + void enterAlter_event_trigger_stmt(PostgreSqlParser.Alter_event_trigger_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_event_trigger_stmt}. + * @param ctx the parse tree + */ + void exitAlter_event_trigger_stmt(PostgreSqlParser.Alter_event_trigger_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_extension_stmt}. + * @param ctx the parse tree + */ + void enterAlter_extension_stmt(PostgreSqlParser.Alter_extension_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_extension_stmt}. + * @param ctx the parse tree + */ + void exitAlter_extension_stmt(PostgreSqlParser.Alter_extension_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_data_wrapper_stmt}. + * @param ctx the parse tree + */ + void enterAlter_foreign_data_wrapper_stmt(PostgreSqlParser.Alter_foreign_data_wrapper_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_data_wrapper_stmt}. + * @param ctx the parse tree + */ + void exitAlter_foreign_data_wrapper_stmt(PostgreSqlParser.Alter_foreign_data_wrapper_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action}. + * @param ctx the parse tree + */ + void enterAlter_foreign_table_action(PostgreSqlParser.Alter_foreign_table_actionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action}. + * @param ctx the parse tree + */ + void exitAlter_foreign_table_action(PostgreSqlParser.Alter_foreign_table_actionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action_list}. + * @param ctx the parse tree + */ + void enterAlter_foreign_table_action_list(PostgreSqlParser.Alter_foreign_table_action_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_action_list}. + * @param ctx the parse tree + */ + void exitAlter_foreign_table_action_list(PostgreSqlParser.Alter_foreign_table_action_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_stmt}. + * @param ctx the parse tree + */ + void enterAlter_foreign_table_stmt(PostgreSqlParser.Alter_foreign_table_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_foreign_table_stmt}. + * @param ctx the parse tree + */ + void exitAlter_foreign_table_stmt(PostgreSqlParser.Alter_foreign_table_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_function_stmt}. + * @param ctx the parse tree + */ + void enterAlter_function_stmt(PostgreSqlParser.Alter_function_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_function_stmt}. + * @param ctx the parse tree + */ + void exitAlter_function_stmt(PostgreSqlParser.Alter_function_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_group_stmt}. + * @param ctx the parse tree + */ + void enterAlter_group_stmt(PostgreSqlParser.Alter_group_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_group_stmt}. + * @param ctx the parse tree + */ + void exitAlter_group_stmt(PostgreSqlParser.Alter_group_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_index_stmt}. + * @param ctx the parse tree + */ + void enterAlter_index_stmt(PostgreSqlParser.Alter_index_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_index_stmt}. + * @param ctx the parse tree + */ + void exitAlter_index_stmt(PostgreSqlParser.Alter_index_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_language_stmt}. + * @param ctx the parse tree + */ + void enterAlter_language_stmt(PostgreSqlParser.Alter_language_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_language_stmt}. + * @param ctx the parse tree + */ + void exitAlter_language_stmt(PostgreSqlParser.Alter_language_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_large_object_stmt}. + * @param ctx the parse tree + */ + void enterAlter_large_object_stmt(PostgreSqlParser.Alter_large_object_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_large_object_stmt}. + * @param ctx the parse tree + */ + void exitAlter_large_object_stmt(PostgreSqlParser.Alter_large_object_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_materialize_view_stmt}. + * @param ctx the parse tree + */ + void enterAlter_materialize_view_stmt(PostgreSqlParser.Alter_materialize_view_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_materialize_view_stmt}. + * @param ctx the parse tree + */ + void exitAlter_materialize_view_stmt(PostgreSqlParser.Alter_materialize_view_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_operator_stmt}. + * @param ctx the parse tree + */ + void enterAlter_operator_stmt(PostgreSqlParser.Alter_operator_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_operator_stmt}. + * @param ctx the parse tree + */ + void exitAlter_operator_stmt(PostgreSqlParser.Alter_operator_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_operator_class_stmt}. + * @param ctx the parse tree + */ + void enterAlter_operator_class_stmt(PostgreSqlParser.Alter_operator_class_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_operator_class_stmt}. + * @param ctx the parse tree + */ + void exitAlter_operator_class_stmt(PostgreSqlParser.Alter_operator_class_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_operator_family_stmt}. + * @param ctx the parse tree + */ + void enterAlter_operator_family_stmt(PostgreSqlParser.Alter_operator_family_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_operator_family_stmt}. + * @param ctx the parse tree + */ + void exitAlter_operator_family_stmt(PostgreSqlParser.Alter_operator_family_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_policy_stmt}. + * @param ctx the parse tree + */ + void enterAlter_policy_stmt(PostgreSqlParser.Alter_policy_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_policy_stmt}. + * @param ctx the parse tree + */ + void exitAlter_policy_stmt(PostgreSqlParser.Alter_policy_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_publication_stmt}. + * @param ctx the parse tree + */ + void enterAlter_publication_stmt(PostgreSqlParser.Alter_publication_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_publication_stmt}. + * @param ctx the parse tree + */ + void exitAlter_publication_stmt(PostgreSqlParser.Alter_publication_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_role_options}. + * @param ctx the parse tree + */ + void enterAlter_role_options(PostgreSqlParser.Alter_role_optionsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_role_options}. + * @param ctx the parse tree + */ + void exitAlter_role_options(PostgreSqlParser.Alter_role_optionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_role_stmt}. + * @param ctx the parse tree + */ + void enterAlter_role_stmt(PostgreSqlParser.Alter_role_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_role_stmt}. + * @param ctx the parse tree + */ + void exitAlter_role_stmt(PostgreSqlParser.Alter_role_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_rule_stmt}. + * @param ctx the parse tree + */ + void enterAlter_rule_stmt(PostgreSqlParser.Alter_rule_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_rule_stmt}. + * @param ctx the parse tree + */ + void exitAlter_rule_stmt(PostgreSqlParser.Alter_rule_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_schema_stmt}. + * @param ctx the parse tree + */ + void enterAlter_schema_stmt(PostgreSqlParser.Alter_schema_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_schema_stmt}. + * @param ctx the parse tree + */ + void exitAlter_schema_stmt(PostgreSqlParser.Alter_schema_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_sequence_stmt}. + * @param ctx the parse tree + */ + void enterAlter_sequence_stmt(PostgreSqlParser.Alter_sequence_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_sequence_stmt}. + * @param ctx the parse tree + */ + void exitAlter_sequence_stmt(PostgreSqlParser.Alter_sequence_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_server_options_list}. + * @param ctx the parse tree + */ + void enterAlter_server_options_list(PostgreSqlParser.Alter_server_options_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_server_options_list}. + * @param ctx the parse tree + */ + void exitAlter_server_options_list(PostgreSqlParser.Alter_server_options_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_server_stmt}. + * @param ctx the parse tree + */ + void enterAlter_server_stmt(PostgreSqlParser.Alter_server_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_server_stmt}. + * @param ctx the parse tree + */ + void exitAlter_server_stmt(PostgreSqlParser.Alter_server_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_statistics_stmt}. + * @param ctx the parse tree + */ + void enterAlter_statistics_stmt(PostgreSqlParser.Alter_statistics_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_statistics_stmt}. + * @param ctx the parse tree + */ + void exitAlter_statistics_stmt(PostgreSqlParser.Alter_statistics_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_subscription_stmt}. + * @param ctx the parse tree + */ + void enterAlter_subscription_stmt(PostgreSqlParser.Alter_subscription_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_subscription_stmt}. + * @param ctx the parse tree + */ + void exitAlter_subscription_stmt(PostgreSqlParser.Alter_subscription_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_system_stmt}. + * @param ctx the parse tree + */ + void enterAlter_system_stmt(PostgreSqlParser.Alter_system_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_system_stmt}. + * @param ctx the parse tree + */ + void exitAlter_system_stmt(PostgreSqlParser.Alter_system_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_table_stmt}. + * @param ctx the parse tree + */ + void enterAlter_table_stmt(PostgreSqlParser.Alter_table_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_table_stmt}. + * @param ctx the parse tree + */ + void exitAlter_table_stmt(PostgreSqlParser.Alter_table_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_tablespace_stmt}. + * @param ctx the parse tree + */ + void enterAlter_tablespace_stmt(PostgreSqlParser.Alter_tablespace_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_tablespace_stmt}. + * @param ctx the parse tree + */ + void exitAlter_tablespace_stmt(PostgreSqlParser.Alter_tablespace_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_config_stmt}. + * @param ctx the parse tree + */ + void enterAlter_text_search_config_stmt(PostgreSqlParser.Alter_text_search_config_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_config_stmt}. + * @param ctx the parse tree + */ + void exitAlter_text_search_config_stmt(PostgreSqlParser.Alter_text_search_config_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_dict_stmt}. + * @param ctx the parse tree + */ + void enterAlter_text_search_dict_stmt(PostgreSqlParser.Alter_text_search_dict_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_dict_stmt}. + * @param ctx the parse tree + */ + void exitAlter_text_search_dict_stmt(PostgreSqlParser.Alter_text_search_dict_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_parser_stmt}. + * @param ctx the parse tree + */ + void enterAlter_text_search_parser_stmt(PostgreSqlParser.Alter_text_search_parser_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_parser_stmt}. + * @param ctx the parse tree + */ + void exitAlter_text_search_parser_stmt(PostgreSqlParser.Alter_text_search_parser_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_text_search_template_stmt}. + * @param ctx the parse tree + */ + void enterAlter_text_search_template_stmt(PostgreSqlParser.Alter_text_search_template_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_text_search_template_stmt}. + * @param ctx the parse tree + */ + void exitAlter_text_search_template_stmt(PostgreSqlParser.Alter_text_search_template_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_trigger_stmt}. + * @param ctx the parse tree + */ + void enterAlter_trigger_stmt(PostgreSqlParser.Alter_trigger_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_trigger_stmt}. + * @param ctx the parse tree + */ + void exitAlter_trigger_stmt(PostgreSqlParser.Alter_trigger_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_type_stmt}. + * @param ctx the parse tree + */ + void enterAlter_type_stmt(PostgreSqlParser.Alter_type_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_type_stmt}. + * @param ctx the parse tree + */ + void exitAlter_type_stmt(PostgreSqlParser.Alter_type_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_user_stmt}. + * @param ctx the parse tree + */ + void enterAlter_user_stmt(PostgreSqlParser.Alter_user_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_user_stmt}. + * @param ctx the parse tree + */ + void exitAlter_user_stmt(PostgreSqlParser.Alter_user_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_user_mapping_stmt}. + * @param ctx the parse tree + */ + void enterAlter_user_mapping_stmt(PostgreSqlParser.Alter_user_mapping_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_user_mapping_stmt}. + * @param ctx the parse tree + */ + void exitAlter_user_mapping_stmt(PostgreSqlParser.Alter_user_mapping_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alter_view_stmt}. + * @param ctx the parse tree + */ + void enterAlter_view_stmt(PostgreSqlParser.Alter_view_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alter_view_stmt}. + * @param ctx the parse tree + */ + void exitAlter_view_stmt(PostgreSqlParser.Alter_view_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#analyze_stmt}. + * @param ctx the parse tree + */ + void enterAnalyze_stmt(PostgreSqlParser.Analyze_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#analyze_stmt}. + * @param ctx the parse tree + */ + void exitAnalyze_stmt(PostgreSqlParser.Analyze_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#close_stmt}. + * @param ctx the parse tree + */ + void enterClose_stmt(PostgreSqlParser.Close_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#close_stmt}. + * @param ctx the parse tree + */ + void exitClose_stmt(PostgreSqlParser.Close_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#cluster_stmt}. + * @param ctx the parse tree + */ + void enterCluster_stmt(PostgreSqlParser.Cluster_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#cluster_stmt}. + * @param ctx the parse tree + */ + void exitCluster_stmt(PostgreSqlParser.Cluster_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#comment_stmt}. + * @param ctx the parse tree + */ + void enterComment_stmt(PostgreSqlParser.Comment_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#comment_stmt}. + * @param ctx the parse tree + */ + void exitComment_stmt(PostgreSqlParser.Comment_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#commit_stmt}. + * @param ctx the parse tree + */ + void enterCommit_stmt(PostgreSqlParser.Commit_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#commit_stmt}. + * @param ctx the parse tree + */ + void exitCommit_stmt(PostgreSqlParser.Commit_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#commit_prepared_stmt}. + * @param ctx the parse tree + */ + void enterCommit_prepared_stmt(PostgreSqlParser.Commit_prepared_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#commit_prepared_stmt}. + * @param ctx the parse tree + */ + void exitCommit_prepared_stmt(PostgreSqlParser.Commit_prepared_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#copy_stmt}. + * @param ctx the parse tree + */ + void enterCopy_stmt(PostgreSqlParser.Copy_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#copy_stmt}. + * @param ctx the parse tree + */ + void exitCopy_stmt(PostgreSqlParser.Copy_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_stmt}. + * @param ctx the parse tree + */ + void enterCreate_stmt(PostgreSqlParser.Create_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_stmt}. + * @param ctx the parse tree + */ + void exitCreate_stmt(PostgreSqlParser.Create_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_access_method_stmt}. + * @param ctx the parse tree + */ + void enterCreate_access_method_stmt(PostgreSqlParser.Create_access_method_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_access_method_stmt}. + * @param ctx the parse tree + */ + void exitCreate_access_method_stmt(PostgreSqlParser.Create_access_method_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_aggregate_stmt}. + * @param ctx the parse tree + */ + void enterCreate_aggregate_stmt(PostgreSqlParser.Create_aggregate_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_aggregate_stmt}. + * @param ctx the parse tree + */ + void exitCreate_aggregate_stmt(PostgreSqlParser.Create_aggregate_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_cast_stmt}. + * @param ctx the parse tree + */ + void enterCreate_cast_stmt(PostgreSqlParser.Create_cast_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_cast_stmt}. + * @param ctx the parse tree + */ + void exitCreate_cast_stmt(PostgreSqlParser.Create_cast_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_collation_opt}. + * @param ctx the parse tree + */ + void enterCreate_collation_opt(PostgreSqlParser.Create_collation_optContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_collation_opt}. + * @param ctx the parse tree + */ + void exitCreate_collation_opt(PostgreSqlParser.Create_collation_optContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_collation_opt_list}. + * @param ctx the parse tree + */ + void enterCreate_collation_opt_list(PostgreSqlParser.Create_collation_opt_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_collation_opt_list}. + * @param ctx the parse tree + */ + void exitCreate_collation_opt_list(PostgreSqlParser.Create_collation_opt_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_collation_stmt}. + * @param ctx the parse tree + */ + void enterCreate_collation_stmt(PostgreSqlParser.Create_collation_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_collation_stmt}. + * @param ctx the parse tree + */ + void exitCreate_collation_stmt(PostgreSqlParser.Create_collation_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_conversion_stmt}. + * @param ctx the parse tree + */ + void enterCreate_conversion_stmt(PostgreSqlParser.Create_conversion_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_conversion_stmt}. + * @param ctx the parse tree + */ + void exitCreate_conversion_stmt(PostgreSqlParser.Create_conversion_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_database_stmt}. + * @param ctx the parse tree + */ + void enterCreate_database_stmt(PostgreSqlParser.Create_database_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_database_stmt}. + * @param ctx the parse tree + */ + void exitCreate_database_stmt(PostgreSqlParser.Create_database_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#domain_constraint}. + * @param ctx the parse tree + */ + void enterDomain_constraint(PostgreSqlParser.Domain_constraintContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#domain_constraint}. + * @param ctx the parse tree + */ + void exitDomain_constraint(PostgreSqlParser.Domain_constraintContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_domain_stmt}. + * @param ctx the parse tree + */ + void enterCreate_domain_stmt(PostgreSqlParser.Create_domain_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_domain_stmt}. + * @param ctx the parse tree + */ + void exitCreate_domain_stmt(PostgreSqlParser.Create_domain_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_event_trigger_cond}. + * @param ctx the parse tree + */ + void enterCreate_event_trigger_cond(PostgreSqlParser.Create_event_trigger_condContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_event_trigger_cond}. + * @param ctx the parse tree + */ + void exitCreate_event_trigger_cond(PostgreSqlParser.Create_event_trigger_condContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_event_trigger_stmt}. + * @param ctx the parse tree + */ + void enterCreate_event_trigger_stmt(PostgreSqlParser.Create_event_trigger_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_event_trigger_stmt}. + * @param ctx the parse tree + */ + void exitCreate_event_trigger_stmt(PostgreSqlParser.Create_event_trigger_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_foreign_data_options}. + * @param ctx the parse tree + */ + void enterCreate_foreign_data_options(PostgreSqlParser.Create_foreign_data_optionsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_foreign_data_options}. + * @param ctx the parse tree + */ + void exitCreate_foreign_data_options(PostgreSqlParser.Create_foreign_data_optionsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_foreign_data_stmt}. + * @param ctx the parse tree + */ + void enterCreate_foreign_data_stmt(PostgreSqlParser.Create_foreign_data_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_foreign_data_stmt}. + * @param ctx the parse tree + */ + void exitCreate_foreign_data_stmt(PostgreSqlParser.Create_foreign_data_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_foreign_table_stmt}. + * @param ctx the parse tree + */ + void enterCreate_foreign_table_stmt(PostgreSqlParser.Create_foreign_table_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_foreign_table_stmt}. + * @param ctx the parse tree + */ + void exitCreate_foreign_table_stmt(PostgreSqlParser.Create_foreign_table_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_function_stmt}. + * @param ctx the parse tree + */ + void enterCreate_function_stmt(PostgreSqlParser.Create_function_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_function_stmt}. + * @param ctx the parse tree + */ + void exitCreate_function_stmt(PostgreSqlParser.Create_function_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_group_stmt}. + * @param ctx the parse tree + */ + void enterCreate_group_stmt(PostgreSqlParser.Create_group_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_group_stmt}. + * @param ctx the parse tree + */ + void exitCreate_group_stmt(PostgreSqlParser.Create_group_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_index_stmt}. + * @param ctx the parse tree + */ + void enterCreate_index_stmt(PostgreSqlParser.Create_index_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_index_stmt}. + * @param ctx the parse tree + */ + void exitCreate_index_stmt(PostgreSqlParser.Create_index_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_language_stmt}. + * @param ctx the parse tree + */ + void enterCreate_language_stmt(PostgreSqlParser.Create_language_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_language_stmt}. + * @param ctx the parse tree + */ + void exitCreate_language_stmt(PostgreSqlParser.Create_language_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_materialized_view_stmt}. + * @param ctx the parse tree + */ + void enterCreate_materialized_view_stmt(PostgreSqlParser.Create_materialized_view_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_materialized_view_stmt}. + * @param ctx the parse tree + */ + void exitCreate_materialized_view_stmt(PostgreSqlParser.Create_materialized_view_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_stmt}. + * @param ctx the parse tree + */ + void enterCreate_operator_stmt(PostgreSqlParser.Create_operator_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_stmt}. + * @param ctx the parse tree + */ + void exitCreate_operator_stmt(PostgreSqlParser.Create_operator_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_class_opt}. + * @param ctx the parse tree + */ + void enterCreate_operator_class_opt(PostgreSqlParser.Create_operator_class_optContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_class_opt}. + * @param ctx the parse tree + */ + void exitCreate_operator_class_opt(PostgreSqlParser.Create_operator_class_optContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_class_stmt}. + * @param ctx the parse tree + */ + void enterCreate_operator_class_stmt(PostgreSqlParser.Create_operator_class_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_class_stmt}. + * @param ctx the parse tree + */ + void exitCreate_operator_class_stmt(PostgreSqlParser.Create_operator_class_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_operator_family_stmt}. + * @param ctx the parse tree + */ + void enterCreate_operator_family_stmt(PostgreSqlParser.Create_operator_family_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_operator_family_stmt}. + * @param ctx the parse tree + */ + void exitCreate_operator_family_stmt(PostgreSqlParser.Create_operator_family_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_policy_stmt}. + * @param ctx the parse tree + */ + void enterCreate_policy_stmt(PostgreSqlParser.Create_policy_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_policy_stmt}. + * @param ctx the parse tree + */ + void exitCreate_policy_stmt(PostgreSqlParser.Create_policy_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_role_stmt}. + * @param ctx the parse tree + */ + void enterCreate_role_stmt(PostgreSqlParser.Create_role_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_role_stmt}. + * @param ctx the parse tree + */ + void exitCreate_role_stmt(PostgreSqlParser.Create_role_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_rule_event}. + * @param ctx the parse tree + */ + void enterCreate_rule_event(PostgreSqlParser.Create_rule_eventContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_rule_event}. + * @param ctx the parse tree + */ + void exitCreate_rule_event(PostgreSqlParser.Create_rule_eventContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_rule_stmt}. + * @param ctx the parse tree + */ + void enterCreate_rule_stmt(PostgreSqlParser.Create_rule_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_rule_stmt}. + * @param ctx the parse tree + */ + void exitCreate_rule_stmt(PostgreSqlParser.Create_rule_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_schema_stmt}. + * @param ctx the parse tree + */ + void enterCreate_schema_stmt(PostgreSqlParser.Create_schema_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_schema_stmt}. + * @param ctx the parse tree + */ + void exitCreate_schema_stmt(PostgreSqlParser.Create_schema_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_sequence_stmt}. + * @param ctx the parse tree + */ + void enterCreate_sequence_stmt(PostgreSqlParser.Create_sequence_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_sequence_stmt}. + * @param ctx the parse tree + */ + void exitCreate_sequence_stmt(PostgreSqlParser.Create_sequence_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_server_stmt}. + * @param ctx the parse tree + */ + void enterCreate_server_stmt(PostgreSqlParser.Create_server_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_server_stmt}. + * @param ctx the parse tree + */ + void exitCreate_server_stmt(PostgreSqlParser.Create_server_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_statistics_stmt}. + * @param ctx the parse tree + */ + void enterCreate_statistics_stmt(PostgreSqlParser.Create_statistics_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_statistics_stmt}. + * @param ctx the parse tree + */ + void exitCreate_statistics_stmt(PostgreSqlParser.Create_statistics_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_subscription_stmt}. + * @param ctx the parse tree + */ + void enterCreate_subscription_stmt(PostgreSqlParser.Create_subscription_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_subscription_stmt}. + * @param ctx the parse tree + */ + void exitCreate_subscription_stmt(PostgreSqlParser.Create_subscription_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_table_stmt}. + * @param ctx the parse tree + */ + void enterCreate_table_stmt(PostgreSqlParser.Create_table_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_table_stmt}. + * @param ctx the parse tree + */ + void exitCreate_table_stmt(PostgreSqlParser.Create_table_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_table_as_stmt}. + * @param ctx the parse tree + */ + void enterCreate_table_as_stmt(PostgreSqlParser.Create_table_as_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_table_as_stmt}. + * @param ctx the parse tree + */ + void exitCreate_table_as_stmt(PostgreSqlParser.Create_table_as_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_tablespace_stmt}. + * @param ctx the parse tree + */ + void enterCreate_tablespace_stmt(PostgreSqlParser.Create_tablespace_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_tablespace_stmt}. + * @param ctx the parse tree + */ + void exitCreate_tablespace_stmt(PostgreSqlParser.Create_tablespace_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_config_stmt}. + * @param ctx the parse tree + */ + void enterCreate_text_search_config_stmt(PostgreSqlParser.Create_text_search_config_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_config_stmt}. + * @param ctx the parse tree + */ + void exitCreate_text_search_config_stmt(PostgreSqlParser.Create_text_search_config_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_dict_stmt}. + * @param ctx the parse tree + */ + void enterCreate_text_search_dict_stmt(PostgreSqlParser.Create_text_search_dict_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_dict_stmt}. + * @param ctx the parse tree + */ + void exitCreate_text_search_dict_stmt(PostgreSqlParser.Create_text_search_dict_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_parser_stmt}. + * @param ctx the parse tree + */ + void enterCreate_text_search_parser_stmt(PostgreSqlParser.Create_text_search_parser_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_parser_stmt}. + * @param ctx the parse tree + */ + void exitCreate_text_search_parser_stmt(PostgreSqlParser.Create_text_search_parser_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_text_search_template_stmt}. + * @param ctx the parse tree + */ + void enterCreate_text_search_template_stmt(PostgreSqlParser.Create_text_search_template_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_text_search_template_stmt}. + * @param ctx the parse tree + */ + void exitCreate_text_search_template_stmt(PostgreSqlParser.Create_text_search_template_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_transform_stmt}. + * @param ctx the parse tree + */ + void enterCreate_transform_stmt(PostgreSqlParser.Create_transform_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_transform_stmt}. + * @param ctx the parse tree + */ + void exitCreate_transform_stmt(PostgreSqlParser.Create_transform_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_trigger_stmt}. + * @param ctx the parse tree + */ + void enterCreate_trigger_stmt(PostgreSqlParser.Create_trigger_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_trigger_stmt}. + * @param ctx the parse tree + */ + void exitCreate_trigger_stmt(PostgreSqlParser.Create_trigger_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_type_stmt}. + * @param ctx the parse tree + */ + void enterCreate_type_stmt(PostgreSqlParser.Create_type_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_type_stmt}. + * @param ctx the parse tree + */ + void exitCreate_type_stmt(PostgreSqlParser.Create_type_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_user_stmt}. + * @param ctx the parse tree + */ + void enterCreate_user_stmt(PostgreSqlParser.Create_user_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_user_stmt}. + * @param ctx the parse tree + */ + void exitCreate_user_stmt(PostgreSqlParser.Create_user_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_user_mapping_stmt}. + * @param ctx the parse tree + */ + void enterCreate_user_mapping_stmt(PostgreSqlParser.Create_user_mapping_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_user_mapping_stmt}. + * @param ctx the parse tree + */ + void exitCreate_user_mapping_stmt(PostgreSqlParser.Create_user_mapping_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#create_view_stmt}. + * @param ctx the parse tree + */ + void enterCreate_view_stmt(PostgreSqlParser.Create_view_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#create_view_stmt}. + * @param ctx the parse tree + */ + void exitCreate_view_stmt(PostgreSqlParser.Create_view_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#deallocate_stmt}. + * @param ctx the parse tree + */ + void enterDeallocate_stmt(PostgreSqlParser.Deallocate_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#deallocate_stmt}. + * @param ctx the parse tree + */ + void exitDeallocate_stmt(PostgreSqlParser.Deallocate_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#declare_stmt}. + * @param ctx the parse tree + */ + void enterDeclare_stmt(PostgreSqlParser.Declare_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#declare_stmt}. + * @param ctx the parse tree + */ + void exitDeclare_stmt(PostgreSqlParser.Declare_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#delete_stmt}. + * @param ctx the parse tree + */ + void enterDelete_stmt(PostgreSqlParser.Delete_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#delete_stmt}. + * @param ctx the parse tree + */ + void exitDelete_stmt(PostgreSqlParser.Delete_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#discard_stmt}. + * @param ctx the parse tree + */ + void enterDiscard_stmt(PostgreSqlParser.Discard_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#discard_stmt}. + * @param ctx the parse tree + */ + void exitDiscard_stmt(PostgreSqlParser.Discard_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_stmt}. + * @param ctx the parse tree + */ + void enterDrop_stmt(PostgreSqlParser.Drop_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_stmt}. + * @param ctx the parse tree + */ + void exitDrop_stmt(PostgreSqlParser.Drop_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_access_method_stmt}. + * @param ctx the parse tree + */ + void enterDrop_access_method_stmt(PostgreSqlParser.Drop_access_method_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_access_method_stmt}. + * @param ctx the parse tree + */ + void exitDrop_access_method_stmt(PostgreSqlParser.Drop_access_method_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_aggregate_stmt}. + * @param ctx the parse tree + */ + void enterDrop_aggregate_stmt(PostgreSqlParser.Drop_aggregate_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_aggregate_stmt}. + * @param ctx the parse tree + */ + void exitDrop_aggregate_stmt(PostgreSqlParser.Drop_aggregate_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_cast_stmt}. + * @param ctx the parse tree + */ + void enterDrop_cast_stmt(PostgreSqlParser.Drop_cast_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_cast_stmt}. + * @param ctx the parse tree + */ + void exitDrop_cast_stmt(PostgreSqlParser.Drop_cast_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_collation_stmt}. + * @param ctx the parse tree + */ + void enterDrop_collation_stmt(PostgreSqlParser.Drop_collation_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_collation_stmt}. + * @param ctx the parse tree + */ + void exitDrop_collation_stmt(PostgreSqlParser.Drop_collation_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_conversion_stmt}. + * @param ctx the parse tree + */ + void enterDrop_conversion_stmt(PostgreSqlParser.Drop_conversion_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_conversion_stmt}. + * @param ctx the parse tree + */ + void exitDrop_conversion_stmt(PostgreSqlParser.Drop_conversion_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_database_stmt}. + * @param ctx the parse tree + */ + void enterDrop_database_stmt(PostgreSqlParser.Drop_database_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_database_stmt}. + * @param ctx the parse tree + */ + void exitDrop_database_stmt(PostgreSqlParser.Drop_database_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_domain_stmt}. + * @param ctx the parse tree + */ + void enterDrop_domain_stmt(PostgreSqlParser.Drop_domain_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_domain_stmt}. + * @param ctx the parse tree + */ + void exitDrop_domain_stmt(PostgreSqlParser.Drop_domain_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_event_trigger_stmt}. + * @param ctx the parse tree + */ + void enterDrop_event_trigger_stmt(PostgreSqlParser.Drop_event_trigger_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_event_trigger_stmt}. + * @param ctx the parse tree + */ + void exitDrop_event_trigger_stmt(PostgreSqlParser.Drop_event_trigger_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_extension_stmt}. + * @param ctx the parse tree + */ + void enterDrop_extension_stmt(PostgreSqlParser.Drop_extension_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_extension_stmt}. + * @param ctx the parse tree + */ + void exitDrop_extension_stmt(PostgreSqlParser.Drop_extension_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_foreign_data_wrapper_stmt}. + * @param ctx the parse tree + */ + void enterDrop_foreign_data_wrapper_stmt(PostgreSqlParser.Drop_foreign_data_wrapper_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_foreign_data_wrapper_stmt}. + * @param ctx the parse tree + */ + void exitDrop_foreign_data_wrapper_stmt(PostgreSqlParser.Drop_foreign_data_wrapper_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_foreign_table_stmt}. + * @param ctx the parse tree + */ + void enterDrop_foreign_table_stmt(PostgreSqlParser.Drop_foreign_table_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_foreign_table_stmt}. + * @param ctx the parse tree + */ + void exitDrop_foreign_table_stmt(PostgreSqlParser.Drop_foreign_table_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_function_stmt}. + * @param ctx the parse tree + */ + void enterDrop_function_stmt(PostgreSqlParser.Drop_function_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_function_stmt}. + * @param ctx the parse tree + */ + void exitDrop_function_stmt(PostgreSqlParser.Drop_function_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_group_stmt}. + * @param ctx the parse tree + */ + void enterDrop_group_stmt(PostgreSqlParser.Drop_group_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_group_stmt}. + * @param ctx the parse tree + */ + void exitDrop_group_stmt(PostgreSqlParser.Drop_group_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_index_stmt}. + * @param ctx the parse tree + */ + void enterDrop_index_stmt(PostgreSqlParser.Drop_index_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_index_stmt}. + * @param ctx the parse tree + */ + void exitDrop_index_stmt(PostgreSqlParser.Drop_index_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_language_stmt}. + * @param ctx the parse tree + */ + void enterDrop_language_stmt(PostgreSqlParser.Drop_language_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_language_stmt}. + * @param ctx the parse tree + */ + void exitDrop_language_stmt(PostgreSqlParser.Drop_language_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_materialized_view_stmt}. + * @param ctx the parse tree + */ + void enterDrop_materialized_view_stmt(PostgreSqlParser.Drop_materialized_view_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_materialized_view_stmt}. + * @param ctx the parse tree + */ + void exitDrop_materialized_view_stmt(PostgreSqlParser.Drop_materialized_view_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_operator_stmt}. + * @param ctx the parse tree + */ + void enterDrop_operator_stmt(PostgreSqlParser.Drop_operator_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_operator_stmt}. + * @param ctx the parse tree + */ + void exitDrop_operator_stmt(PostgreSqlParser.Drop_operator_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_operator_class_stmt}. + * @param ctx the parse tree + */ + void enterDrop_operator_class_stmt(PostgreSqlParser.Drop_operator_class_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_operator_class_stmt}. + * @param ctx the parse tree + */ + void exitDrop_operator_class_stmt(PostgreSqlParser.Drop_operator_class_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_operator_family_stmt}. + * @param ctx the parse tree + */ + void enterDrop_operator_family_stmt(PostgreSqlParser.Drop_operator_family_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_operator_family_stmt}. + * @param ctx the parse tree + */ + void exitDrop_operator_family_stmt(PostgreSqlParser.Drop_operator_family_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_owned_stmt}. + * @param ctx the parse tree + */ + void enterDrop_owned_stmt(PostgreSqlParser.Drop_owned_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_owned_stmt}. + * @param ctx the parse tree + */ + void exitDrop_owned_stmt(PostgreSqlParser.Drop_owned_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_policy_stmt}. + * @param ctx the parse tree + */ + void enterDrop_policy_stmt(PostgreSqlParser.Drop_policy_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_policy_stmt}. + * @param ctx the parse tree + */ + void exitDrop_policy_stmt(PostgreSqlParser.Drop_policy_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_publication_stmt}. + * @param ctx the parse tree + */ + void enterDrop_publication_stmt(PostgreSqlParser.Drop_publication_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_publication_stmt}. + * @param ctx the parse tree + */ + void exitDrop_publication_stmt(PostgreSqlParser.Drop_publication_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_role_stmt}. + * @param ctx the parse tree + */ + void enterDrop_role_stmt(PostgreSqlParser.Drop_role_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_role_stmt}. + * @param ctx the parse tree + */ + void exitDrop_role_stmt(PostgreSqlParser.Drop_role_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_rule_stmt}. + * @param ctx the parse tree + */ + void enterDrop_rule_stmt(PostgreSqlParser.Drop_rule_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_rule_stmt}. + * @param ctx the parse tree + */ + void exitDrop_rule_stmt(PostgreSqlParser.Drop_rule_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_schema_stmt}. + * @param ctx the parse tree + */ + void enterDrop_schema_stmt(PostgreSqlParser.Drop_schema_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_schema_stmt}. + * @param ctx the parse tree + */ + void exitDrop_schema_stmt(PostgreSqlParser.Drop_schema_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_sequence_stmt}. + * @param ctx the parse tree + */ + void enterDrop_sequence_stmt(PostgreSqlParser.Drop_sequence_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_sequence_stmt}. + * @param ctx the parse tree + */ + void exitDrop_sequence_stmt(PostgreSqlParser.Drop_sequence_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_server_stmt}. + * @param ctx the parse tree + */ + void enterDrop_server_stmt(PostgreSqlParser.Drop_server_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_server_stmt}. + * @param ctx the parse tree + */ + void exitDrop_server_stmt(PostgreSqlParser.Drop_server_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_statistics_stmt}. + * @param ctx the parse tree + */ + void enterDrop_statistics_stmt(PostgreSqlParser.Drop_statistics_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_statistics_stmt}. + * @param ctx the parse tree + */ + void exitDrop_statistics_stmt(PostgreSqlParser.Drop_statistics_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_subscription_stmt}. + * @param ctx the parse tree + */ + void enterDrop_subscription_stmt(PostgreSqlParser.Drop_subscription_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_subscription_stmt}. + * @param ctx the parse tree + */ + void exitDrop_subscription_stmt(PostgreSqlParser.Drop_subscription_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_table_stmt}. + * @param ctx the parse tree + */ + void enterDrop_table_stmt(PostgreSqlParser.Drop_table_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_table_stmt}. + * @param ctx the parse tree + */ + void exitDrop_table_stmt(PostgreSqlParser.Drop_table_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_tablespace_stmt}. + * @param ctx the parse tree + */ + void enterDrop_tablespace_stmt(PostgreSqlParser.Drop_tablespace_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_tablespace_stmt}. + * @param ctx the parse tree + */ + void exitDrop_tablespace_stmt(PostgreSqlParser.Drop_tablespace_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_config_stmt}. + * @param ctx the parse tree + */ + void enterDrop_text_search_config_stmt(PostgreSqlParser.Drop_text_search_config_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_config_stmt}. + * @param ctx the parse tree + */ + void exitDrop_text_search_config_stmt(PostgreSqlParser.Drop_text_search_config_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_dict_stmt}. + * @param ctx the parse tree + */ + void enterDrop_text_search_dict_stmt(PostgreSqlParser.Drop_text_search_dict_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_dict_stmt}. + * @param ctx the parse tree + */ + void exitDrop_text_search_dict_stmt(PostgreSqlParser.Drop_text_search_dict_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_parser_stmt}. + * @param ctx the parse tree + */ + void enterDrop_text_search_parser_stmt(PostgreSqlParser.Drop_text_search_parser_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_parser_stmt}. + * @param ctx the parse tree + */ + void exitDrop_text_search_parser_stmt(PostgreSqlParser.Drop_text_search_parser_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_text_search_template_stmt}. + * @param ctx the parse tree + */ + void enterDrop_text_search_template_stmt(PostgreSqlParser.Drop_text_search_template_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_text_search_template_stmt}. + * @param ctx the parse tree + */ + void exitDrop_text_search_template_stmt(PostgreSqlParser.Drop_text_search_template_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_transform_stmt}. + * @param ctx the parse tree + */ + void enterDrop_transform_stmt(PostgreSqlParser.Drop_transform_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_transform_stmt}. + * @param ctx the parse tree + */ + void exitDrop_transform_stmt(PostgreSqlParser.Drop_transform_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_trigger_stmt}. + * @param ctx the parse tree + */ + void enterDrop_trigger_stmt(PostgreSqlParser.Drop_trigger_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_trigger_stmt}. + * @param ctx the parse tree + */ + void exitDrop_trigger_stmt(PostgreSqlParser.Drop_trigger_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_type_stmt}. + * @param ctx the parse tree + */ + void enterDrop_type_stmt(PostgreSqlParser.Drop_type_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_type_stmt}. + * @param ctx the parse tree + */ + void exitDrop_type_stmt(PostgreSqlParser.Drop_type_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_user_stmt}. + * @param ctx the parse tree + */ + void enterDrop_user_stmt(PostgreSqlParser.Drop_user_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_user_stmt}. + * @param ctx the parse tree + */ + void exitDrop_user_stmt(PostgreSqlParser.Drop_user_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_user_mapping_stmt}. + * @param ctx the parse tree + */ + void enterDrop_user_mapping_stmt(PostgreSqlParser.Drop_user_mapping_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_user_mapping_stmt}. + * @param ctx the parse tree + */ + void exitDrop_user_mapping_stmt(PostgreSqlParser.Drop_user_mapping_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#drop_view_stmt}. + * @param ctx the parse tree + */ + void enterDrop_view_stmt(PostgreSqlParser.Drop_view_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#drop_view_stmt}. + * @param ctx the parse tree + */ + void exitDrop_view_stmt(PostgreSqlParser.Drop_view_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#execute_stmt}. + * @param ctx the parse tree + */ + void enterExecute_stmt(PostgreSqlParser.Execute_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#execute_stmt}. + * @param ctx the parse tree + */ + void exitExecute_stmt(PostgreSqlParser.Execute_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explain_stmt}. + * @param ctx the parse tree + */ + void enterExplain_stmt(PostgreSqlParser.Explain_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explain_stmt}. + * @param ctx the parse tree + */ + void exitExplain_stmt(PostgreSqlParser.Explain_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#fetch_stmt}. + * @param ctx the parse tree + */ + void enterFetch_stmt(PostgreSqlParser.Fetch_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#fetch_stmt}. + * @param ctx the parse tree + */ + void exitFetch_stmt(PostgreSqlParser.Fetch_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#grant_stmt}. + * @param ctx the parse tree + */ + void enterGrant_stmt(PostgreSqlParser.Grant_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#grant_stmt}. + * @param ctx the parse tree + */ + void exitGrant_stmt(PostgreSqlParser.Grant_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#import_foreign_schema_stmt}. + * @param ctx the parse tree + */ + void enterImport_foreign_schema_stmt(PostgreSqlParser.Import_foreign_schema_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#import_foreign_schema_stmt}. + * @param ctx the parse tree + */ + void exitImport_foreign_schema_stmt(PostgreSqlParser.Import_foreign_schema_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#insert_stmt}. + * @param ctx the parse tree + */ + void enterInsert_stmt(PostgreSqlParser.Insert_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#insert_stmt}. + * @param ctx the parse tree + */ + void exitInsert_stmt(PostgreSqlParser.Insert_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#listen_stmt}. + * @param ctx the parse tree + */ + void enterListen_stmt(PostgreSqlParser.Listen_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#listen_stmt}. + * @param ctx the parse tree + */ + void exitListen_stmt(PostgreSqlParser.Listen_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#load_stmt}. + * @param ctx the parse tree + */ + void enterLoad_stmt(PostgreSqlParser.Load_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#load_stmt}. + * @param ctx the parse tree + */ + void exitLoad_stmt(PostgreSqlParser.Load_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#lock_stmt}. + * @param ctx the parse tree + */ + void enterLock_stmt(PostgreSqlParser.Lock_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#lock_stmt}. + * @param ctx the parse tree + */ + void exitLock_stmt(PostgreSqlParser.Lock_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#move_stmt}. + * @param ctx the parse tree + */ + void enterMove_stmt(PostgreSqlParser.Move_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#move_stmt}. + * @param ctx the parse tree + */ + void exitMove_stmt(PostgreSqlParser.Move_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#notify_stmt}. + * @param ctx the parse tree + */ + void enterNotify_stmt(PostgreSqlParser.Notify_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#notify_stmt}. + * @param ctx the parse tree + */ + void exitNotify_stmt(PostgreSqlParser.Notify_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#prepare_stmt}. + * @param ctx the parse tree + */ + void enterPrepare_stmt(PostgreSqlParser.Prepare_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#prepare_stmt}. + * @param ctx the parse tree + */ + void exitPrepare_stmt(PostgreSqlParser.Prepare_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#prepare_transaction_stmt}. + * @param ctx the parse tree + */ + void enterPrepare_transaction_stmt(PostgreSqlParser.Prepare_transaction_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#prepare_transaction_stmt}. + * @param ctx the parse tree + */ + void exitPrepare_transaction_stmt(PostgreSqlParser.Prepare_transaction_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reassign_owned_stmt}. + * @param ctx the parse tree + */ + void enterReassign_owned_stmt(PostgreSqlParser.Reassign_owned_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reassign_owned_stmt}. + * @param ctx the parse tree + */ + void exitReassign_owned_stmt(PostgreSqlParser.Reassign_owned_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#refresh_materialized_view_stmt}. + * @param ctx the parse tree + */ + void enterRefresh_materialized_view_stmt(PostgreSqlParser.Refresh_materialized_view_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#refresh_materialized_view_stmt}. + * @param ctx the parse tree + */ + void exitRefresh_materialized_view_stmt(PostgreSqlParser.Refresh_materialized_view_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reindex_stmt}. + * @param ctx the parse tree + */ + void enterReindex_stmt(PostgreSqlParser.Reindex_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reindex_stmt}. + * @param ctx the parse tree + */ + void exitReindex_stmt(PostgreSqlParser.Reindex_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#release_savepoint_stmt}. + * @param ctx the parse tree + */ + void enterRelease_savepoint_stmt(PostgreSqlParser.Release_savepoint_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#release_savepoint_stmt}. + * @param ctx the parse tree + */ + void exitRelease_savepoint_stmt(PostgreSqlParser.Release_savepoint_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#reset_stmt}. + * @param ctx the parse tree + */ + void enterReset_stmt(PostgreSqlParser.Reset_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#reset_stmt}. + * @param ctx the parse tree + */ + void exitReset_stmt(PostgreSqlParser.Reset_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#revoke_stmt}. + * @param ctx the parse tree + */ + void enterRevoke_stmt(PostgreSqlParser.Revoke_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#revoke_stmt}. + * @param ctx the parse tree + */ + void exitRevoke_stmt(PostgreSqlParser.Revoke_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rollback_stmt}. + * @param ctx the parse tree + */ + void enterRollback_stmt(PostgreSqlParser.Rollback_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rollback_stmt}. + * @param ctx the parse tree + */ + void exitRollback_stmt(PostgreSqlParser.Rollback_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rollback_prepared_stmt}. + * @param ctx the parse tree + */ + void enterRollback_prepared_stmt(PostgreSqlParser.Rollback_prepared_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rollback_prepared_stmt}. + * @param ctx the parse tree + */ + void exitRollback_prepared_stmt(PostgreSqlParser.Rollback_prepared_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#rollback_to_savepoint_stmt}. + * @param ctx the parse tree + */ + void enterRollback_to_savepoint_stmt(PostgreSqlParser.Rollback_to_savepoint_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#rollback_to_savepoint_stmt}. + * @param ctx the parse tree + */ + void exitRollback_to_savepoint_stmt(PostgreSqlParser.Rollback_to_savepoint_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#savepoint_stmt}. + * @param ctx the parse tree + */ + void enterSavepoint_stmt(PostgreSqlParser.Savepoint_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#savepoint_stmt}. + * @param ctx the parse tree + */ + void exitSavepoint_stmt(PostgreSqlParser.Savepoint_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#security_label_stmt}. + * @param ctx the parse tree + */ + void enterSecurity_label_stmt(PostgreSqlParser.Security_label_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#security_label_stmt}. + * @param ctx the parse tree + */ + void exitSecurity_label_stmt(PostgreSqlParser.Security_label_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#select_stmt}. + * @param ctx the parse tree + */ + void enterSelect_stmt(PostgreSqlParser.Select_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#select_stmt}. + * @param ctx the parse tree + */ + void exitSelect_stmt(PostgreSqlParser.Select_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#select_into_stmt}. + * @param ctx the parse tree + */ + void enterSelect_into_stmt(PostgreSqlParser.Select_into_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#select_into_stmt}. + * @param ctx the parse tree + */ + void exitSelect_into_stmt(PostgreSqlParser.Select_into_stmtContext 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#with_expr}. + * @param ctx the parse tree + */ + void enterWith_expr(PostgreSqlParser.With_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#with_expr}. + * @param ctx the parse tree + */ + void exitWith_expr(PostgreSqlParser.With_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_stmt}. + * @param ctx the parse tree + */ + void enterSet_stmt(PostgreSqlParser.Set_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_stmt}. + * @param ctx the parse tree + */ + void exitSet_stmt(PostgreSqlParser.Set_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_constraints_stmt}. + * @param ctx the parse tree + */ + void enterSet_constraints_stmt(PostgreSqlParser.Set_constraints_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_constraints_stmt}. + * @param ctx the parse tree + */ + void exitSet_constraints_stmt(PostgreSqlParser.Set_constraints_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_role_stmt}. + * @param ctx the parse tree + */ + void enterSet_role_stmt(PostgreSqlParser.Set_role_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_role_stmt}. + * @param ctx the parse tree + */ + void exitSet_role_stmt(PostgreSqlParser.Set_role_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_session_authorization_stmt}. + * @param ctx the parse tree + */ + void enterSet_session_authorization_stmt(PostgreSqlParser.Set_session_authorization_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_session_authorization_stmt}. + * @param ctx the parse tree + */ + void exitSet_session_authorization_stmt(PostgreSqlParser.Set_session_authorization_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transaction_mode}. + * @param ctx the parse tree + */ + void enterTransaction_mode(PostgreSqlParser.Transaction_modeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transaction_mode}. + * @param ctx the parse tree + */ + void exitTransaction_mode(PostgreSqlParser.Transaction_modeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#transaction_mode_list}. + * @param ctx the parse tree + */ + void enterTransaction_mode_list(PostgreSqlParser.Transaction_mode_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#transaction_mode_list}. + * @param ctx the parse tree + */ + void exitTransaction_mode_list(PostgreSqlParser.Transaction_mode_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#set_transaction_stmt}. + * @param ctx the parse tree + */ + void enterSet_transaction_stmt(PostgreSqlParser.Set_transaction_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#set_transaction_stmt}. + * @param ctx the parse tree + */ + void exitSet_transaction_stmt(PostgreSqlParser.Set_transaction_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#show_stmt}. + * @param ctx the parse tree + */ + void enterShow_stmt(PostgreSqlParser.Show_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#show_stmt}. + * @param ctx the parse tree + */ + void exitShow_stmt(PostgreSqlParser.Show_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#truncate_stmt}. + * @param ctx the parse tree + */ + void enterTruncate_stmt(PostgreSqlParser.Truncate_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#truncate_stmt}. + * @param ctx the parse tree + */ + void exitTruncate_stmt(PostgreSqlParser.Truncate_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#unlisten_stmt}. + * @param ctx the parse tree + */ + void enterUnlisten_stmt(PostgreSqlParser.Unlisten_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#unlisten_stmt}. + * @param ctx the parse tree + */ + void exitUnlisten_stmt(PostgreSqlParser.Unlisten_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#update_stmt}. + * @param ctx the parse tree + */ + void enterUpdate_stmt(PostgreSqlParser.Update_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#update_stmt}. + * @param ctx the parse tree + */ + void exitUpdate_stmt(PostgreSqlParser.Update_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_opt}. + * @param ctx the parse tree + */ + void enterVacuum_opt(PostgreSqlParser.Vacuum_optContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_opt}. + * @param ctx the parse tree + */ + void exitVacuum_opt(PostgreSqlParser.Vacuum_optContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_opt_list}. + * @param ctx the parse tree + */ + void enterVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_opt_list}. + * @param ctx the parse tree + */ + void exitVacuum_opt_list(PostgreSqlParser.Vacuum_opt_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#vacuum_stmt}. + * @param ctx the parse tree + */ + void enterVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#vacuum_stmt}. + * @param ctx the parse tree + */ + void exitVacuum_stmt(PostgreSqlParser.Vacuum_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#values_stmt}. + * @param ctx the parse tree + */ + void enterValues_stmt(PostgreSqlParser.Values_stmtContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#values_stmt}. + * @param ctx the parse tree + */ + void exitValues_stmt(PostgreSqlParser.Values_stmtContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#selector_clause}. + * @param ctx the parse tree + */ + void enterSelector_clause(PostgreSqlParser.Selector_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#selector_clause}. + * @param ctx the parse tree + */ + void exitSelector_clause(PostgreSqlParser.Selector_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#from_clause}. + * @param ctx the parse tree + */ + void enterFrom_clause(PostgreSqlParser.From_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#from_clause}. + * @param ctx the parse tree + */ + void exitFrom_clause(PostgreSqlParser.From_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#where_clause}. + * @param ctx the parse tree + */ + void enterWhere_clause(PostgreSqlParser.Where_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#where_clause}. + * @param ctx the parse tree + */ + void exitWhere_clause(PostgreSqlParser.Where_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#group_by_clause}. + * @param ctx the parse tree + */ + void enterGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#group_by_clause}. + * @param ctx the parse tree + */ + void exitGroup_by_clause(PostgreSqlParser.Group_by_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#grouping_elem}. + * @param ctx the parse tree + */ + void enterGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#grouping_elem}. + * @param ctx the parse tree + */ + void exitGrouping_elem(PostgreSqlParser.Grouping_elemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#grouping_elem_list}. + * @param ctx the parse tree + */ + void enterGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#grouping_elem_list}. + * @param ctx the parse tree + */ + void exitGrouping_elem_list(PostgreSqlParser.Grouping_elem_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#having_clause}. + * @param ctx the parse tree + */ + void enterHaving_clause(PostgreSqlParser.Having_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#having_clause}. + * @param ctx the parse tree + */ + void exitHaving_clause(PostgreSqlParser.Having_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#column_list}. + * @param ctx the parse tree + */ + void enterColumn_list(PostgreSqlParser.Column_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#column_list}. + * @param ctx the parse tree + */ + void exitColumn_list(PostgreSqlParser.Column_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#explain_parameter}. + * @param ctx the parse tree + */ + void enterExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#explain_parameter}. + * @param ctx the parse tree + */ + void exitExplain_parameter(PostgreSqlParser.Explain_parameterContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#frame}. + * @param ctx the parse tree + */ + void enterFrame(PostgreSqlParser.FrameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#frame}. + * @param ctx the parse tree + */ + void exitFrame(PostgreSqlParser.FrameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#frame_start}. + * @param ctx the parse tree + */ + void enterFrame_start(PostgreSqlParser.Frame_startContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#frame_start}. + * @param ctx the parse tree + */ + void exitFrame_start(PostgreSqlParser.Frame_startContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#frame_end}. + * @param ctx the parse tree + */ + void enterFrame_end(PostgreSqlParser.Frame_endContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#frame_end}. + * @param ctx the parse tree + */ + void exitFrame_end(PostgreSqlParser.Frame_endContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#frame_clause}. + * @param ctx the parse tree + */ + void enterFrame_clause(PostgreSqlParser.Frame_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#frame_clause}. + * @param ctx the parse tree + */ + void exitFrame_clause(PostgreSqlParser.Frame_clauseContext 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#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#combine_clause}. + * @param ctx the parse tree + */ + void enterCombine_clause(PostgreSqlParser.Combine_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#combine_clause}. + * @param ctx the parse tree + */ + void exitCombine_clause(PostgreSqlParser.Combine_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#order_by_clause}. + * @param ctx the parse tree + */ + void enterOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#order_by_clause}. + * @param ctx the parse tree + */ + void exitOrder_by_clause(PostgreSqlParser.Order_by_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#order_by_item}. + * @param ctx the parse tree + */ + void enterOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#order_by_item}. + * @param ctx the parse tree + */ + void exitOrder_by_item(PostgreSqlParser.Order_by_itemContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#limit_clause}. + * @param ctx the parse tree + */ + void enterLimit_clause(PostgreSqlParser.Limit_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#limit_clause}. + * @param ctx the parse tree + */ + void exitLimit_clause(PostgreSqlParser.Limit_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#offset_clause}. + * @param ctx the parse tree + */ + void enterOffset_clause(PostgreSqlParser.Offset_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#offset_clause}. + * @param ctx the parse tree + */ + void exitOffset_clause(PostgreSqlParser.Offset_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#fetch_clause}. + * @param ctx the parse tree + */ + void enterFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#fetch_clause}. + * @param ctx the parse tree + */ + void exitFetch_clause(PostgreSqlParser.Fetch_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#for_clause}. + * @param ctx the parse tree + */ + void enterFor_clause(PostgreSqlParser.For_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#for_clause}. + * @param ctx the parse tree + */ + void exitFor_clause(PostgreSqlParser.For_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#updater_clause}. + * @param ctx the parse tree + */ + void enterUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#updater_clause}. + * @param ctx the parse tree + */ + void exitUpdater_clause(PostgreSqlParser.Updater_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#updater_expr}. + * @param ctx the parse tree + */ + void enterUpdater_expr(PostgreSqlParser.Updater_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#updater_expr}. + * @param ctx the parse tree + */ + void exitUpdater_expr(PostgreSqlParser.Updater_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#expr}. + * @param ctx the parse tree + */ + void enterExpr(PostgreSqlParser.ExprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#expr}. + * @param ctx the parse tree + */ + void exitExpr(PostgreSqlParser.ExprContext 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); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#bool_expr}. + * @param ctx the parse tree + */ + void enterBool_expr(PostgreSqlParser.Bool_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#bool_expr}. + * @param ctx the parse tree + */ + void exitBool_expr(PostgreSqlParser.Bool_exprContext 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#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#expr_list_list}. + * @param ctx the parse tree + */ + void enterExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#expr_list_list}. + * @param ctx the parse tree + */ + void exitExpr_list_list(PostgreSqlParser.Expr_list_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_sig_arg}. + * @param ctx the parse tree + */ + void enterFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_sig_arg}. + * @param ctx the parse tree + */ + void exitFunc_sig_arg(PostgreSqlParser.Func_sig_argContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_sig_arg_list}. + * @param ctx the parse tree + */ + void enterFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_sig_arg_list}. + * @param ctx the parse tree + */ + void exitFunc_sig_arg_list(PostgreSqlParser.Func_sig_arg_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_sig}. + * @param ctx the parse tree + */ + void enterFunc_sig(PostgreSqlParser.Func_sigContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_sig}. + * @param ctx the parse tree + */ + void exitFunc_sig(PostgreSqlParser.Func_sigContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#func_sig_list}. + * @param ctx the parse tree + */ + void enterFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#func_sig_list}. + * @param ctx the parse tree + */ + void exitFunc_sig_list(PostgreSqlParser.Func_sig_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#type_name}. + * @param ctx the parse tree + */ + void enterType_name(PostgreSqlParser.Type_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#type_name}. + * @param ctx the parse tree + */ + void exitType_name(PostgreSqlParser.Type_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#timezone}. + * @param ctx the parse tree + */ + void enterTimezone(PostgreSqlParser.TimezoneContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#timezone}. + * @param ctx the parse tree + */ + void exitTimezone(PostgreSqlParser.TimezoneContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#oper}. + * @param ctx the parse tree + */ + void enterOper(PostgreSqlParser.OperContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#oper}. + * @param ctx the parse tree + */ + void exitOper(PostgreSqlParser.OperContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aggregate}. + * @param ctx the parse tree + */ + void enterAggregate(PostgreSqlParser.AggregateContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aggregate}. + * @param ctx the parse tree + */ + void exitAggregate(PostgreSqlParser.AggregateContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#name_}. + * @param ctx the parse tree + */ + void enterName_(PostgreSqlParser.Name_Context ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#name_}. + * @param ctx the parse tree + */ + void exitName_(PostgreSqlParser.Name_Context 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#identifier_list}. + * @param ctx the parse tree + */ + void enterIdentifier_list(PostgreSqlParser.Identifier_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#identifier_list}. + * @param ctx the parse tree + */ + void exitIdentifier_list(PostgreSqlParser.Identifier_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#option_expr}. + * @param ctx the parse tree + */ + void enterOption_expr(PostgreSqlParser.Option_exprContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#option_expr}. + * @param ctx the parse tree + */ + void exitOption_expr(PostgreSqlParser.Option_exprContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#option_list}. + * @param ctx the parse tree + */ + void enterOption_list(PostgreSqlParser.Option_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#option_list}. + * @param ctx the parse tree + */ + void exitOption_list(PostgreSqlParser.Option_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#table_name_}. + * @param ctx the parse tree + */ + void enterTable_name_(PostgreSqlParser.Table_name_Context ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#table_name_}. + * @param ctx the parse tree + */ + void exitTable_name_(PostgreSqlParser.Table_name_Context ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#data_type}. + * @param ctx the parse tree + */ + void enterData_type(PostgreSqlParser.Data_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#data_type}. + * @param ctx the parse tree + */ + void exitData_type(PostgreSqlParser.Data_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#data_type_list}. + * @param ctx the parse tree + */ + void enterData_type_list(PostgreSqlParser.Data_type_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#data_type_list}. + * @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); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#join_type}. + * @param ctx the parse tree + */ + void enterJoin_type(PostgreSqlParser.Join_typeContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#join_type}. + * @param ctx the parse tree + */ + void exitJoin_type(PostgreSqlParser.Join_typeContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#join_clause}. + * @param ctx the parse tree + */ + void enterJoin_clause(PostgreSqlParser.Join_clauseContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#join_clause}. + * @param ctx the parse tree + */ + void exitJoin_clause(PostgreSqlParser.Join_clauseContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#predicate}. + * @param ctx the parse tree + */ + void enterPredicate(PostgreSqlParser.PredicateContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#predicate}. + * @param ctx the parse tree + */ + void exitPredicate(PostgreSqlParser.PredicateContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#aggregate_signature}. + * @param ctx the parse tree + */ + void enterAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#aggregate_signature}. + * @param ctx the parse tree + */ + void exitAggregate_signature(PostgreSqlParser.Aggregate_signatureContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#column_constraint}. + * @param ctx the parse tree + */ + void enterColumn_constraint(PostgreSqlParser.Column_constraintContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#column_constraint}. + * @param ctx the parse tree + */ + void exitColumn_constraint(PostgreSqlParser.Column_constraintContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#column_constraints}. + * @param ctx the parse tree + */ + void enterColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#column_constraints}. + * @param ctx the parse tree + */ + void exitColumn_constraints(PostgreSqlParser.Column_constraintsContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#index_parameters}. + * @param ctx the parse tree + */ + void enterIndex_parameters(PostgreSqlParser.Index_parametersContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#index_parameters}. + * @param ctx the parse tree + */ + void exitIndex_parameters(PostgreSqlParser.Index_parametersContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#exclude_element}. + * @param ctx the parse tree + */ + void enterExclude_element(PostgreSqlParser.Exclude_elementContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#exclude_element}. + * @param ctx the parse tree + */ + void exitExclude_element(PostgreSqlParser.Exclude_elementContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#table_constraint}. + * @param ctx the parse tree + */ + void enterTable_constraint(PostgreSqlParser.Table_constraintContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#table_constraint}. + * @param ctx the parse tree + */ + void exitTable_constraint(PostgreSqlParser.Table_constraintContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#role_name}. + * @param ctx the parse tree + */ + void enterRole_name(PostgreSqlParser.Role_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#role_name}. + * @param ctx the parse tree + */ + void exitRole_name(PostgreSqlParser.Role_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#role_name_list}. + * @param ctx the parse tree + */ + void enterRole_name_list(PostgreSqlParser.Role_name_listContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#role_name_list}. + * @param ctx the parse tree + */ + void exitRole_name_list(PostgreSqlParser.Role_name_listContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#param_value}. + * @param ctx the parse tree + */ + void enterParam_value(PostgreSqlParser.Param_valueContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#param_value}. + * @param ctx the parse tree + */ + void exitParam_value(PostgreSqlParser.Param_valueContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#non_reserved_keyword}. + * @param ctx the parse tree + */ + void enterNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#non_reserved_keyword}. + * @param ctx the parse tree + */ + void exitNon_reserved_keyword(PostgreSqlParser.Non_reserved_keywordContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#identifier}. + * @param ctx the parse tree + */ + void enterIdentifier(PostgreSqlParser.IdentifierContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#identifier}. + * @param ctx the parse tree + */ + void exitIdentifier(PostgreSqlParser.IdentifierContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#todo_fill_in}. + * @param ctx the parse tree + */ + void enterTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#todo_fill_in}. + * @param ctx the parse tree + */ + void exitTodo_fill_in(PostgreSqlParser.Todo_fill_inContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#todo_implement}. + * @param ctx the parse tree + */ + void enterTodo_implement(PostgreSqlParser.Todo_implementContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#todo_implement}. + * @param ctx the parse tree + */ + void exitTodo_implement(PostgreSqlParser.Todo_implementContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#correlation_name}. + * @param ctx the parse tree + */ + void enterCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#correlation_name}. + * @param ctx the parse tree + */ + void exitCorrelation_name(PostgreSqlParser.Correlation_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#column_name}. + * @param ctx the parse tree + */ + void enterColumn_name(PostgreSqlParser.Column_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#column_name}. + * @param ctx the parse tree + */ + void exitColumn_name(PostgreSqlParser.Column_nameContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#alias}. + * @param ctx the parse tree + */ + void enterAlias(PostgreSqlParser.AliasContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#alias}. + * @param ctx the parse tree + */ + void exitAlias(PostgreSqlParser.AliasContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#column_alias}. + * @param ctx the parse tree + */ + void enterColumn_alias(PostgreSqlParser.Column_aliasContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#column_alias}. + * @param ctx the parse tree + */ + void exitColumn_alias(PostgreSqlParser.Column_aliasContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#column_definition}. + * @param ctx the parse tree + */ + void enterColumn_definition(PostgreSqlParser.Column_definitionContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#column_definition}. + * @param ctx the parse tree + */ + void exitColumn_definition(PostgreSqlParser.Column_definitionContext ctx); + /** + * Enter a parse tree produced by {@link PostgreSqlParser#window_name}. + * @param ctx the parse tree + */ + void enterWindow_name(PostgreSqlParser.Window_nameContext ctx); + /** + * Exit a parse tree produced by {@link PostgreSqlParser#window_name}. + * @param ctx the parse tree + */ + void exitWindow_name(PostgreSqlParser.Window_nameContext 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/HqlSemanticTokens.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokens.java index 26b9ff531..7c3d32c87 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokens.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokens.java @@ -11,17 +11,25 @@ package org.springframework.ide.vscode.boot.java.data.jpa.queries; import java.util.ArrayList; +import java.util.BitSet; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.function.Consumer; +import org.antlr.v4.runtime.ANTLRErrorListener; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.ConsoleErrorListener; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.Recognizer; import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.atn.ATNConfigSet; +import org.antlr.v4.runtime.dfa.DFA; import org.antlr.v4.runtime.tree.ErrorNode; import org.antlr.v4.runtime.tree.TerminalNode; import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; @@ -40,13 +48,19 @@ public class HqlSemanticTokens implements SemanticTokensDataProvider { private static List TOKEN_TYPES = List.of("keyword", "type", "class", "string", "number", "operator", "variable", "method", "parameter"); - private Optional optSpelTokens; + private final Optional optSpelTokens; + + private final Optional> parseErrorHandler; public HqlSemanticTokens(Optional optSpelTokens) { - this.optSpelTokens = optSpelTokens; - + this(optSpelTokens, Optional.empty()); } - + + public HqlSemanticTokens(Optional optSpelTokens, Optional> parseErrorHandler) { + this.optSpelTokens = optSpelTokens; + this.parseErrorHandler = parseErrorHandler; + } + @Override public List getTokenTypes() { LinkedHashSet tokenTypes = new LinkedHashSet<>(TOKEN_TYPES); @@ -136,6 +150,30 @@ public class HqlSemanticTokens implements SemanticTokensDataProvider { }); + parser.addErrorListener(new ANTLRErrorListener() { + + @Override + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, + String msg, RecognitionException e) { + parseErrorHandler.ifPresent(h -> h.accept(e)); + } + + @Override + public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, + ATNConfigSet configs) { + } + + @Override + public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, + BitSet conflictingAlts, ATNConfigSet configs) { + } + + @Override + public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, + BitSet ambigAlts, ATNConfigSet configs) { + } + }); + parser.ql_statement(); semantics.entrySet().stream() diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java index f44236c19..370b5a8f6 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProvider.java @@ -56,6 +56,7 @@ public class JdtDataQuerySemanticTokensProvider implements JdtSemanticTokensProv this.sqlTokenProviders = new LinkedHashMap<>(); this.sqlTokenProviders.put(SqlType.MYSQL, new MySqlSemanticTokens(spelSemanticTokens)); + this.sqlTokenProviders.put(SqlType.POSTGRESQL, new PostgreSqlSemanticTokens(spelSemanticTokens)); } @Override @@ -169,6 +170,11 @@ public class JdtDataQuerySemanticTokensProvider implements JdtSemanticTokensProv } private SemanticTokensDataProvider getSqlSemanticTokensProvider(IJavaProject project) { + if (SpringProjectUtil.hasDependencyStartingWith(project, "mysql-connector", null)) { + return sqlTokenProviders.get(SqlType.MYSQL); + } else if (SpringProjectUtil.hasDependencyStartingWith(project, "postgresql", null)) { + return sqlTokenProviders.get(SqlType.POSTGRESQL); + } return sqlTokenProviders.get(SqlType.MYSQL); } diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokens.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokens.java index 1c28e4147..fff3fc553 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokens.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokens.java @@ -11,17 +11,25 @@ package org.springframework.ide.vscode.boot.java.data.jpa.queries; import java.util.ArrayList; +import java.util.BitSet; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.function.Consumer; +import org.antlr.v4.runtime.ANTLRErrorListener; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.ConsoleErrorListener; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.Recognizer; import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.atn.ATNConfigSet; +import org.antlr.v4.runtime.dfa.DFA; import org.antlr.v4.runtime.tree.ErrorNode; import org.antlr.v4.runtime.tree.TerminalNode; import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; @@ -43,22 +51,29 @@ public class JpqlSemanticTokens implements SemanticTokensDataProvider { private static List TOKEN_TYPES = List.of("keyword", "type", "class", "string", "number", "operator", "variable", "method", "regexp", "parameter"); - final private Optional optSpelSemantictokens; + private final Optional optSpelTokens; + + private final Optional> parseErrorHandler; public JpqlSemanticTokens(Optional optSpelSemantictokens) { - this.optSpelSemantictokens = optSpelSemantictokens; + this(optSpelSemantictokens, Optional.empty()); } + public JpqlSemanticTokens(Optional optSpelTokens, Optional> parseErrorHandler) { + this.optSpelTokens = optSpelTokens; + this.parseErrorHandler = parseErrorHandler; + } + @Override public List getTokenTypes() { LinkedHashSet tokenTypes = new LinkedHashSet<>(TOKEN_TYPES); - tokenTypes.addAll(optSpelSemantictokens.map(s -> s.getTokenTypes()).orElse(Collections.emptyList())); + tokenTypes.addAll(optSpelTokens.map(s -> s.getTokenTypes()).orElse(Collections.emptyList())); return tokenTypes.stream().toList(); } @Override public List getTypeModifiers() { - return optSpelSemantictokens.map(s -> s.getTypeModifiers()).orElse(Collections.emptyList()); + return optSpelTokens.map(s -> s.getTypeModifiers()).orElse(Collections.emptyList()); } @Override @@ -99,7 +114,7 @@ public class JpqlSemanticTokens implements SemanticTokensDataProvider { case JpqlParser.WS: break; case JpqlParser.SPEL: - tokens.addAll(computeTokensFromSpelNode(node, initialOffset, optSpelSemantictokens)); + tokens.addAll(computeTokensFromSpelNode(node, initialOffset, optSpelTokens)); break; default: if (JpqlParser.WS < type && type <= JpqlParser.WHERE) { @@ -156,6 +171,30 @@ public class JpqlSemanticTokens implements SemanticTokensDataProvider { }); + parser.addErrorListener(new ANTLRErrorListener() { + + @Override + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, + String msg, RecognitionException e) { + parseErrorHandler.ifPresent(h -> h.accept(e)); + } + + @Override + public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, + ATNConfigSet configs) { + } + + @Override + public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, + BitSet conflictingAlts, ATNConfigSet configs) { + } + + @Override + public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, + BitSet ambigAlts, ATNConfigSet configs) { + } + }); + parser.ql_statement(); semantics.entrySet().stream() diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokens.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokens.java index 0fbe77817..5bb2a2087 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokens.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokens.java @@ -11,19 +11,27 @@ package org.springframework.ide.vscode.boot.java.data.jpa.queries; import java.util.ArrayList; +import java.util.BitSet; import java.util.Collections; import java.util.HashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.function.Consumer; import java.util.stream.Stream; +import org.antlr.v4.runtime.ANTLRErrorListener; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; import org.antlr.v4.runtime.ConsoleErrorListener; +import org.antlr.v4.runtime.Parser; import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.Recognizer; import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.atn.ATNConfigSet; +import org.antlr.v4.runtime.dfa.DFA; import org.antlr.v4.runtime.tree.ErrorNode; import org.antlr.v4.runtime.tree.TerminalNode; import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; @@ -32,19 +40,26 @@ import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.Sem import org.springframework.ide.vscode.parser.mysql.MySqlLexer; import org.springframework.ide.vscode.parser.mysql.MySqlParser; import org.springframework.ide.vscode.parser.mysql.MySqlParser.ParameterContext; +import org.springframework.ide.vscode.parser.mysql.MySqlParser.UdfFunctionCallContext; import org.springframework.ide.vscode.parser.mysql.MySqlParserBaseListener; public class MySqlSemanticTokens implements SemanticTokensDataProvider { private static List TOKEN_TYPES = List.of("keyword", "type", "string", "number", "operator", - "variable", "regexp", "comment", "parameter"); + "variable", "regexp", "comment", "parameter", "method"); - private Optional optSpelTokens; + private final Optional optSpelTokens; + private final Optional> parseErrorHandler; public MySqlSemanticTokens(Optional optSpelTokens) { - this.optSpelTokens = optSpelTokens; + this(optSpelTokens, Optional.empty()); } + public MySqlSemanticTokens(Optional optSpelTokens, Optional> parseErrorHandler) { + this.optSpelTokens = optSpelTokens; + this.parseErrorHandler = parseErrorHandler; + } + @Override public List getTokenTypes() { LinkedHashSet tokenTypes = new LinkedHashSet<>(TOKEN_TYPES); @@ -82,7 +97,7 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider { semantics.put(node.getSymbol(), "variable"); break; case MySqlParser.DOT_ID: - semantics.put(node.getSymbol(), "variable"); + semantics.put(node.getSymbol(), "property"); break; case MySqlParser.DOT: semantics.put(node.getSymbol(), "operator"); @@ -116,7 +131,7 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider { semantics.put(node.getSymbol(), "comment"); break; default: - if (MySqlParser.VAR_ASSIGN <= type && type <= MySqlParser.COLON_SYMB) { + if (MySqlParser.VAR_ASSIGN <= type && type <= MySqlParser.QUESTION_SYMB) { semantics.put(node.getSymbol(), "operator"); } else if (MySqlParser.DECIMAL_LITERAL <= type && type <= MySqlParser.BIT_STRING) { semantics.put(node.getSymbol(), "number"); @@ -180,6 +195,18 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider { public void visitErrorNode(ErrorNode node) { processTerminalNode(node); } + + + + @Override + public void exitUdfFunctionCall(UdfFunctionCallContext fc) { + if (fc.fullId() != null) { + List ls = getAllLeafs(fc.fullId()).toList(); + if (!ls.isEmpty()) { + semantics.put(ls.get(ls.size() - 1), "method"); + } + } + } @Override public void exitParameter(ParameterContext ctx) { @@ -194,25 +221,55 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider { } } - private Stream getAllLeafs(ParserRuleContext ctx) { - return ctx.children.stream().flatMap(n -> { - if (n instanceof ParserRuleContext prc) { - return getAllLeafs(prc); - } else if (n instanceof TerminalNode tn) { - return Stream.of(tn.getSymbol()); - } - return Stream.empty(); - }); + }); + + parser.addErrorListener(new ANTLRErrorListener() { + + @Override + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, + String msg, RecognitionException e) { + parseErrorHandler.ifPresent(h -> h.accept(e)); } + @Override + public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, + ATNConfigSet configs) { + } + + @Override + public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, + BitSet conflictingAlts, ATNConfigSet configs) { + } + + @Override + public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, + BitSet ambigAlts, ATNConfigSet configs) { + } }); + parser.sqlStatements(); semantics.entrySet().stream() - .map(e -> new SemanticTokenData(e.getKey().getStartIndex() + initialOffset, - e.getKey().getStartIndex() + e.getKey().getText().length() + initialOffset, e.getValue(), - new String[0])) + .flatMap(e -> { + int startIndex = e.getKey().getStartIndex(); + if (e.getKey().getType() == MySqlLexer.DOT_ID) { + return Stream.of( + // the prefix '.' is an operator + new SemanticTokenData(startIndex + initialOffset, + startIndex + 1 + initialOffset, "operator", + new String[0]), + // the rest whatever it was meant to be initially + new SemanticTokenData(startIndex + 1 + initialOffset, + startIndex + e.getKey().getText().length() + initialOffset, e.getValue(), + new String[0]) + ); + } else { + return Stream.of(new SemanticTokenData(startIndex + initialOffset, + startIndex + e.getKey().getText().length() + initialOffset, e.getValue(), + new String[0])); + } + }) .forEach(tokens::add); Collections.sort(tokens); @@ -220,5 +277,18 @@ public class MySqlSemanticTokens implements SemanticTokensDataProvider { return tokens; } + + static Stream getAllLeafs(ParserRuleContext ctx) { + return ctx.children.stream().flatMap(n -> { + if (n instanceof ParserRuleContext prc) { + return getAllLeafs(prc); + } else if (n instanceof TerminalNode tn) { + return Stream.of(tn.getSymbol()); + } + return Stream.empty(); + }); + } + + } 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 new file mode 100644 index 000000000..3917603eb --- /dev/null +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokens.java @@ -0,0 +1,204 @@ +/******************************************************************************* + * Copyright (c) 2024 Broadcom, Inc. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Broadcom, Inc. - initial API and implementation + *******************************************************************************/ +package org.springframework.ide.vscode.boot.java.data.jpa.queries; + +import java.util.ArrayList; +import java.util.BitSet; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Consumer; + +import org.antlr.v4.runtime.ANTLRErrorListener; +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.ConsoleErrorListener; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.Recognizer; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.atn.ATNConfigSet; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; +import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; +import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokenData; +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.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.PostgreSqlParserBaseListener; + +public class PostgreSqlSemanticTokens implements SemanticTokensDataProvider { + + private static List TOKEN_TYPES = List.of("keyword", "type", "string", "number", "operator", + "variable", "regexp", "comment", "parameter", "method"); + + private Optional optSpelTokens; + private Optional> parseErrorHandler; + + public PostgreSqlSemanticTokens(Optional optSpelTokens) { + this(optSpelTokens, Optional.empty()); + } + + public PostgreSqlSemanticTokens(Optional optSpelTokens, Optional> parseErrorHandler) { + this.optSpelTokens = optSpelTokens; + this.parseErrorHandler = parseErrorHandler; + } + + @Override + public List getTokenTypes() { + LinkedHashSet tokenTypes = new LinkedHashSet<>(TOKEN_TYPES); + tokenTypes.addAll(optSpelTokens.map(s -> s.getTokenTypes()).orElse(Collections.emptyList())); + return tokenTypes.stream().toList(); + } + + @Override + public List getTypeModifiers() { + return optSpelTokens.map(s -> s.getTypeModifiers()).orElse(Collections.emptyList()); + } + + @Override + public List computeTokens(String text, int initialOffset) { + PostgreSqlLexer lexer = new PostgreSqlLexer(CharStreams.fromString(text)); + CommonTokenStream antlrTokens = new CommonTokenStream(lexer); + PostgreSqlParser parser = new PostgreSqlParser(antlrTokens); + + Map semantics = new HashMap<>(); + + List tokens = new ArrayList<>(); + + lexer.removeErrorListener(ConsoleErrorListener.INSTANCE); + parser.removeErrorListener(ConsoleErrorListener.INSTANCE); + + parser.addParseListener(new PostgreSqlParserBaseListener() { + + private void processTerminalNode(TerminalNode node) { + Token token = node.getSymbol(); + int type = token.getType(); + if (type >= PostgreSqlLexer.A_ && type <= PostgreSqlLexer.OWNED) { + semantics.put(token, "keyword"); + } else if (type >= PostgreSqlLexer.ABSTIME && type <= PostgreSqlLexer.XML) { + semantics.put(token, "type"); + } else if ((type >= PostgreSqlLexer.AMP && type <= PostgreSqlLexer.SEMI) + || (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) { + semantics.put(token, "string"); + } else if ((type >= PostgreSqlLexer.NUMERIC_LITERAL && type <= PostgreSqlLexer.HEX_INTEGER_LITERAL) + || type == PostgreSqlLexer.DOLLAR_DEC || type == PostgreSqlLexer.BIT_STRING) { + semantics.put(token, "number"); + } else if (type == PostgreSqlLexer.IDENTIFIER) { + semantics.put(token, "variable"); + } else if (type >= PostgreSqlLexer.BLOCK_COMMENT && type <= PostgreSqlLexer.LINE_COMMENT) { + semantics.put(token, "comment"); + } else if (type == PostgreSqlLexer.SPEL) { + tokens.addAll(JpqlSemanticTokens.computeTokensFromSpelNode(node, initialOffset, optSpelTokens)); + } + } + + @Override + public void visitTerminal(TerminalNode node) { + processTerminalNode(node); + } + + @Override + public void visitErrorNode(ErrorNode node) { + 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"); + } + } + + @Override + public void exitData_type(Data_typeContext dataType) { + if (dataType.identifier() != null) { + MySqlSemanticTokens.getAllLeafs(dataType.identifier()) + .filter(t -> t.getType() == PostgreSqlLexer.IDENTIFIER) + .forEach(t -> semantics.put(t, "type")); + } + } + + @Override + public void exitParameter(ParameterContext param) { + if (param.identifier() != null) { + MySqlSemanticTokens.getAllLeafs(param.identifier()).forEach(t -> semantics.put(t, "parameter")); + } + if (param.INTEGER_LITERAL() != null) { + semantics.put(param.INTEGER_LITERAL().getSymbol(), "parameter"); + } + } + + }); + + parser.addErrorListener(new ANTLRErrorListener() { + + @Override + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, + String msg, RecognitionException e) { + parseErrorHandler.ifPresent(h -> h.accept(e)); + } + + @Override + public void reportContextSensitivity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, int prediction, + ATNConfigSet configs) { + } + + @Override + public void reportAttemptingFullContext(Parser recognizer, DFA dfa, int startIndex, int stopIndex, + BitSet conflictingAlts, ATNConfigSet configs) { + } + + @Override + public void reportAmbiguity(Parser recognizer, DFA dfa, int startIndex, int stopIndex, boolean exact, + BitSet ambigAlts, ATNConfigSet configs) { + } + }); + + parser.root(); + + semantics.entrySet().stream() + .map(e -> new SemanticTokenData(e.getKey().getStartIndex() + initialOffset, + e.getKey().getStartIndex() + e.getKey().getText().length() + initialOffset, e.getValue(), + new String[0])) + .forEach(tokens::add); + + Collections.sort(tokens); + + return tokens; + } + +} diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java index 89d984693..def5ce769 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/QueryJdtAstReconciler.java @@ -38,6 +38,8 @@ import org.springframework.ide.vscode.commons.languageserver.reconcile.IProblemC import org.springframework.ide.vscode.commons.languageserver.reconcile.ProblemType; import org.springframework.ide.vscode.parser.mysql.MySqlLexer; import org.springframework.ide.vscode.parser.mysql.MySqlParser; +import org.springframework.ide.vscode.parser.postgresql.PostgreSqlLexer; +import org.springframework.ide.vscode.parser.postgresql.PostgreSqlParser; public class QueryJdtAstReconciler implements JdtAstReconciler { @@ -53,6 +55,7 @@ public class QueryJdtAstReconciler implements JdtAstReconciler { this.sqlReconcilers = new LinkedHashMap<>(); this.sqlReconcilers.put(SqlType.MYSQL, new AntlrReconcilerWithSpel("MySQL", MySqlParser.class, MySqlLexer.class, "sqlStatements", QueryProblemType.SQL_SYNTAX, spelReconciler, MySqlLexer.SPEL)); + this.sqlReconcilers.put(SqlType.POSTGRESQL, new AntlrReconcilerWithSpel("PostgreSQL", PostgreSqlParser.class, PostgreSqlLexer.class, "root", QueryProblemType.SQL_SYNTAX, spelReconciler, PostgreSqlLexer.SPEL)); } @Override @@ -169,6 +172,8 @@ public class QueryJdtAstReconciler implements JdtAstReconciler { private Optional getSqlReconciler(IJavaProject project) { if (SpringProjectUtil.hasDependencyStartingWith(project, "mysql-connector", null)) { return Optional.of(sqlReconcilers.get(SqlType.MYSQL)); + } else if (SpringProjectUtil.hasDependencyStartingWith(project, "postgresql", null)) { + return Optional.of(sqlReconcilers.get(SqlType.POSTGRESQL)); } return Optional.empty(); } diff --git a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlType.java b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlType.java index ae80ddffc..7ba603e99 100644 --- a/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlType.java +++ b/headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/SqlType.java @@ -12,6 +12,7 @@ package org.springframework.ide.vscode.boot.java.data.jpa.queries; public enum SqlType { - MYSQL + MYSQL, + POSTGRESQL } diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokensTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokensTest.java index b23957b3f..bb9d9df16 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokensTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/HqlSemanticTokensTest.java @@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat; import java.util.List; import java.util.Optional; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; @@ -26,7 +27,7 @@ public class HqlSemanticTokensTest { @BeforeEach void setup() { - provider = new HqlSemanticTokens(Optional.empty()); + provider = new HqlSemanticTokens(Optional.empty(), Optional.of(Assertions::fail)); } @Test diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java index 962d570b2..286fecf7f 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JdtDataQuerySemanticTokensProviderTest.java @@ -17,7 +17,6 @@ import java.util.List; import org.eclipse.jdt.core.dom.CompilationUnit; import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.springframework.beans.factory.annotation.Autowired; @@ -45,7 +44,7 @@ public class JdtDataQuerySemanticTokensProviderTest { @BeforeEach public void setup() throws Exception { - jp = projects.mavenProject("boot-sql"); + jp = projects.mavenProject("boot-mysql"); } private List computeTokens(CompilationUnit cu) { @@ -342,21 +341,24 @@ public class JdtDataQuerySemanticTokensProviderTest { assertThat(token).isEqualTo(new SemanticTokenData(156, 157, "variable", new String[0])); token = tokens.get(7); - assertThat(source.substring(token.start(), token.end())).isEqualTo(".status"); - assertThat(token).isEqualTo(new SemanticTokenData(157, 164, "variable", new String[0])); - + assertThat(source.substring(token.start(), token.end())).isEqualTo("."); + assertThat(token).isEqualTo(new SemanticTokenData(157, 158, "operator", new String[0])); + token = tokens.get(8); + assertThat(source.substring(token.start(), token.end())).isEqualTo("status"); + assertThat(token).isEqualTo(new SemanticTokenData(158, 164, "property", new String[0])); + + token = tokens.get(9); assertThat(source.substring(token.start(), token.end())).isEqualTo("="); assertThat(token).isEqualTo(new SemanticTokenData(165, 166, "operator", new String[0])); - token = tokens.get(9); + token = tokens.get(10); assertThat(source.substring(token.start(), token.end())).isEqualTo("1"); assertThat(token).isEqualTo(new SemanticTokenData(167, 168, "number", new String[0])); } @Test - @Disabled("Needs proper SPEL support in SQL grammar") void nativeQueryWithSpel() throws Exception { String source = """ package my.package @@ -406,26 +408,30 @@ public class JdtDataQuerySemanticTokensProviderTest { assertThat(token).isEqualTo(new SemanticTokenData(156, 157, "variable", new String[0])); token = tokens.get(7); - assertThat(source.substring(token.start(), token.end())).isEqualTo(".status"); - assertThat(token).isEqualTo(new SemanticTokenData(157, 164, "variable", new String[0])); - + assertThat(source.substring(token.start(), token.end())).isEqualTo("."); + assertThat(token).isEqualTo(new SemanticTokenData(157, 158, "operator", new String[0])); + token = tokens.get(8); + assertThat(source.substring(token.start(), token.end())).isEqualTo("status"); + assertThat(token).isEqualTo(new SemanticTokenData(158, 164, "property", new String[0])); + + token = tokens.get(9); assertThat(source.substring(token.start(), token.end())).isEqualTo("="); assertThat(token).isEqualTo(new SemanticTokenData(165, 166, "operator", new String[0])); - token = tokens.get(9); + token = tokens.get(10); assertThat(source.substring(token.start(), token.end())).isEqualTo("?"); assertThat(token).isEqualTo(new SemanticTokenData(167, 168, "operator", new String[0])); - token = tokens.get(9); + token = tokens.get(11); assertThat(source.substring(token.start(), token.end())).isEqualTo("#{"); assertThat(token).isEqualTo(new SemanticTokenData(168, 170, "operator", new String[0])); - token = tokens.get(10); + token = tokens.get(12); assertThat(source.substring(token.start(), token.end())).isEqualTo("status"); assertThat(token).isEqualTo(new SemanticTokenData(170, 176, "variable", new String[0])); - token = tokens.get(11); + token = tokens.get(13); assertThat(source.substring(token.start(), token.end())).isEqualTo("}"); assertThat(token).isEqualTo(new SemanticTokenData(176, 177, "operator", new String[0])); } diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokensTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokensTest.java index cecc4b971..f432191c2 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokensTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/JpqlSemanticTokensTest.java @@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat; import java.util.List; import java.util.Optional; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; @@ -26,7 +27,7 @@ public class JpqlSemanticTokensTest { @BeforeEach void setup() { - provider = new JpqlSemanticTokens(Optional.empty()); + provider = new JpqlSemanticTokens(Optional.empty(), Optional.of(Assertions::fail)); } @Test diff --git a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokensTest.java b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokensTest.java index 3fcdb9331..c53a0f18e 100644 --- a/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokensTest.java +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/MySqlSemanticTokensTest.java @@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat; import java.util.List; import java.util.Optional; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; @@ -26,20 +27,27 @@ public class MySqlSemanticTokensTest { @BeforeEach void setup() { - provider = new MySqlSemanticTokens(Optional.of(new SpelSemanticTokens())); + provider = new MySqlSemanticTokens(Optional.of(new SpelSemanticTokens()), Optional.of(Assertions::fail)); } @Test void simple() { - List tokens = provider.computeTokens("SELECT * from fn_module_candidates()", 0); + List tokens = provider.computeTokens("SELECT * from Document document WHERE document.id=fn_module_candidates()", 0); + assertThat(tokens.size()).isEqualTo(13); assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0])); assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 8, "operator", new String[0])); - assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(9, 13, "keyword", new String[0])); - assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(14, 34, "variable", new String[0])); - assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(34, 35, "operator", new String[0])); - assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(35, 36, "operator", new String[0])); + assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(9, 13, "keyword", new String[0])); // from + assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(14, 22, "variable", new String[0])); // Document + assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(23, 31, "variable", new String[0])); // document + assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(32, 37, "keyword", new String[0])); // WHERE + assertThat(tokens.get(6)).isEqualTo(new SemanticTokenData(38, 46, "variable", new String[0])); // document + assertThat(tokens.get(7)).isEqualTo(new SemanticTokenData(46, 47, "operator", new String[0])); // . + assertThat(tokens.get(8)).isEqualTo(new SemanticTokenData(47, 49, "property", new String[0])); // id + assertThat(tokens.get(9)).isEqualTo(new SemanticTokenData(49, 50, "operator", new String[0])); // = + assertThat(tokens.get(10)).isEqualTo(new SemanticTokenData(50, 70, "method", new String[0])); // fn_module_candidates + assertThat(tokens.get(11)).isEqualTo(new SemanticTokenData(70, 71, "operator", new String[0])); // ( + assertThat(tokens.get(12)).isEqualTo(new SemanticTokenData(71, 72, "operator", new String[0])); // ) - assertThat(tokens.size()).isEqualTo(6); } @Test 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 new file mode 100644 index 000000000..efdf1aa8d --- /dev/null +++ b/headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/java/data/jpa/queries/PostgreSqlSemanticTokensTest.java @@ -0,0 +1,84 @@ +/******************************************************************************* + * Copyright (c) 2024 Broadcom, Inc. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Broadcom, Inc. - initial API and implementation + *******************************************************************************/ +package org.springframework.ide.vscode.boot.java.data.jpa.queries; + +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.List; +import java.util.Optional; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.ide.vscode.boot.java.spel.SpelSemanticTokens; +import org.springframework.ide.vscode.commons.languageserver.semantic.tokens.SemanticTokenData; + +public class PostgreSqlSemanticTokensTest { + + private PostgreSqlSemanticTokens provider; + + @BeforeEach + void setup() { + provider = new PostgreSqlSemanticTokens(Optional.of(new SpelSemanticTokens()), Optional.of(Assertions::fail)); + } + + @Test + void simple() { + List tokens = provider.computeTokens("SELECT * from fn_module_candidates", 0); + assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0])); + assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 8, "operator", new String[0])); + assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(9, 13, "keyword", new String[0])); + assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(14, 34, "variable", new String[0])); + + assertThat(tokens.size()).isEqualTo(4); + } + + @Test + void adv_1() { + List tokens = provider.computeTokens(""" + DELETE FROM Represenation representation + WHERE representation.project_id=?1 + AND NOT EXISTS ( + SELECT * FROM Document document + WHERE document.project_id=?1 + AND json_path_exists(document.content::jsonb, ('strict $.content.**.id ? (@ == "\\' || representation.targetobjectid || \\'")')::jsonpath) + ) + """, 0); + assertThat(tokens.size()).isEqualTo(43); + + assertThat(tokens.get(10)).isEqualTo(new SemanticTokenData(74, 75, "parameter", new String[0])); // 1 from ?1 + 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(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])); // :: + } + + @Test + void spelInQuery() { + List tokens = provider.computeTokens("DELETE FROM component_document WHERE item_document_id = :#{someBean}", 0); + assertThat(tokens.get(0)).isEqualTo(new SemanticTokenData(0, 6, "keyword", new String[0])); + assertThat(tokens.get(1)).isEqualTo(new SemanticTokenData(7, 11, "keyword", new String[0])); + assertThat(tokens.get(2)).isEqualTo(new SemanticTokenData(12, 30, "variable", new String[0])); + assertThat(tokens.get(3)).isEqualTo(new SemanticTokenData(31, 36, "keyword", new String[0])); + assertThat(tokens.get(4)).isEqualTo(new SemanticTokenData(37, 53, "variable", new String[0])); + assertThat(tokens.get(5)).isEqualTo(new SemanticTokenData(54, 55, "operator", new String[0])); + assertThat(tokens.get(6)).isEqualTo(new SemanticTokenData(56, 57, "operator", new String[0])); + assertThat(tokens.get(7)).isEqualTo(new SemanticTokenData(57, 59, "operator", new String[0])); + assertThat(tokens.get(8)).isEqualTo(new SemanticTokenData(59, 67, "variable", new String[0])); + assertThat(tokens.get(9)).isEqualTo(new SemanticTokenData(67, 68, "operator", new String[0])); + + assertThat(tokens.size()).isEqualTo(10); + } + +} 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 858cd5b00..e120893ed 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 @@ -47,7 +47,7 @@ public class QueryReconcilerTest { public void setup() throws Exception { harness.intialize(null); - directory = new File(ProjectsHarness.class.getResource("/test-projects/boot-sql/").toURI()); + directory = new File(ProjectsHarness.class.getResource("/test-projects/boot-mysql/").toURI()); String projectDir = directory.toURI().toString(); @@ -209,7 +209,7 @@ public class QueryReconcilerTest { } @Test - void nativeSqlAnnotation() throws Exception { + void nativeMySqlAnnotation() throws Exception { String source = """ package example.demo; @@ -229,6 +229,32 @@ public class QueryReconcilerTest { editor.assertProblems("SELECTX|MySQL: mismatched input 'SELECTX' expecting {'ALTER',"); } + @Test + void nativePostgreSql() throws Exception { + directory = new File(ProjectsHarness.class.getResource("/test-projects/boot-postgresql/").toURI()); + String projectDir = directory.toURI().toString(); + // trigger project creation + projectFinder.find(new TextDocumentIdentifier(projectDir)).get(); + + String source = """ + package example.demo; + + import org.springframework.data.jpa.repository.Query; + import org.springframework.data.repository.Repository; + + public interface OwnerRepository extends Repository { + + @Query(value = "SELECTX ptype FROM PetType", nativeQuery = true) + List findPetTypes(); + + } + """; + 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'"); + } + @Test void noErrorForHql() throws Exception { String source = """ diff --git a/headless-services/spring-boot-language-server/src/test/resources/.gitignore b/headless-services/spring-boot-language-server/src/test/resources/.gitignore new file mode 100644 index 000000000..211ca7149 --- /dev/null +++ b/headless-services/spring-boot-language-server/src/test/resources/.gitignore @@ -0,0 +1 @@ +/test-projects/**/.mvn/ diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/mvnw b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/mvnw similarity index 100% rename from headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/mvnw rename to headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/mvnw diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/mvnw.cmd b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/mvnw.cmd similarity index 100% rename from headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/mvnw.cmd rename to headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/mvnw.cmd diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/pom.xml b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/pom.xml similarity index 100% rename from headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/pom.xml rename to headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-mysql/pom.xml diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw new file mode 100755 index 000000000..66df28542 --- /dev/null +++ b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw @@ -0,0 +1,308 @@ +#!/bin/sh +# ---------------------------------------------------------------------------- +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# ---------------------------------------------------------------------------- + +# ---------------------------------------------------------------------------- +# Apache Maven Wrapper startup batch script, version 3.2.0 +# +# Required ENV vars: +# ------------------ +# JAVA_HOME - location of a JDK home dir +# +# Optional ENV vars +# ----------------- +# MAVEN_OPTS - parameters passed to the Java VM when running Maven +# e.g. to debug Maven itself, use +# set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 +# MAVEN_SKIP_RC - flag to disable loading of mavenrc files +# ---------------------------------------------------------------------------- + +if [ -z "$MAVEN_SKIP_RC" ] ; then + + if [ -f /usr/local/etc/mavenrc ] ; then + . /usr/local/etc/mavenrc + fi + + if [ -f /etc/mavenrc ] ; then + . /etc/mavenrc + fi + + if [ -f "$HOME/.mavenrc" ] ; then + . "$HOME/.mavenrc" + fi + +fi + +# OS specific support. $var _must_ be set to either true or false. +cygwin=false; +darwin=false; +mingw=false +case "$(uname)" in + CYGWIN*) cygwin=true ;; + MINGW*) mingw=true;; + Darwin*) darwin=true + # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home + # See https://developer.apple.com/library/mac/qa/qa1170/_index.html + if [ -z "$JAVA_HOME" ]; then + if [ -x "/usr/libexec/java_home" ]; then + JAVA_HOME="$(/usr/libexec/java_home)"; export JAVA_HOME + else + JAVA_HOME="/Library/Java/Home"; export JAVA_HOME + fi + fi + ;; +esac + +if [ -z "$JAVA_HOME" ] ; then + if [ -r /etc/gentoo-release ] ; then + JAVA_HOME=$(java-config --jre-home) + fi +fi + +# For Cygwin, ensure paths are in UNIX format before anything is touched +if $cygwin ; then + [ -n "$JAVA_HOME" ] && + JAVA_HOME=$(cygpath --unix "$JAVA_HOME") + [ -n "$CLASSPATH" ] && + CLASSPATH=$(cygpath --path --unix "$CLASSPATH") +fi + +# For Mingw, ensure paths are in UNIX format before anything is touched +if $mingw ; then + [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] && + JAVA_HOME="$(cd "$JAVA_HOME" || (echo "cannot cd into $JAVA_HOME."; exit 1); pwd)" +fi + +if [ -z "$JAVA_HOME" ]; then + javaExecutable="$(which javac)" + if [ -n "$javaExecutable" ] && ! [ "$(expr "\"$javaExecutable\"" : '\([^ ]*\)')" = "no" ]; then + # readlink(1) is not available as standard on Solaris 10. + readLink=$(which readlink) + if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then + if $darwin ; then + javaHome="$(dirname "\"$javaExecutable\"")" + javaExecutable="$(cd "\"$javaHome\"" && pwd -P)/javac" + else + javaExecutable="$(readlink -f "\"$javaExecutable\"")" + fi + javaHome="$(dirname "\"$javaExecutable\"")" + javaHome=$(expr "$javaHome" : '\(.*\)/bin') + JAVA_HOME="$javaHome" + export JAVA_HOME + fi + fi +fi + +if [ -z "$JAVACMD" ] ; then + if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + else + JAVACMD="$(\unset -f command 2>/dev/null; \command -v java)" + fi +fi + +if [ ! -x "$JAVACMD" ] ; then + echo "Error: JAVA_HOME is not defined correctly." >&2 + echo " We cannot execute $JAVACMD" >&2 + exit 1 +fi + +if [ -z "$JAVA_HOME" ] ; then + echo "Warning: JAVA_HOME environment variable is not set." +fi + +# traverses directory structure from process work directory to filesystem root +# first directory with .mvn subdirectory is considered project base directory +find_maven_basedir() { + if [ -z "$1" ] + then + echo "Path not specified to find_maven_basedir" + return 1 + fi + + basedir="$1" + wdir="$1" + while [ "$wdir" != '/' ] ; do + if [ -d "$wdir"/.mvn ] ; then + basedir=$wdir + break + fi + # workaround for JBEAP-8937 (on Solaris 10/Sparc) + if [ -d "${wdir}" ]; then + wdir=$(cd "$wdir/.." || exit 1; pwd) + fi + # end of workaround + done + printf '%s' "$(cd "$basedir" || exit 1; pwd)" +} + +# concatenates all lines of a file +concat_lines() { + if [ -f "$1" ]; then + # Remove \r in case we run on Windows within Git Bash + # and check out the repository with auto CRLF management + # enabled. Otherwise, we may read lines that are delimited with + # \r\n and produce $'-Xarg\r' rather than -Xarg due to word + # splitting rules. + tr -s '\r\n' ' ' < "$1" + fi +} + +log() { + if [ "$MVNW_VERBOSE" = true ]; then + printf '%s\n' "$1" + fi +} + +BASE_DIR=$(find_maven_basedir "$(dirname "$0")") +if [ -z "$BASE_DIR" ]; then + exit 1; +fi + +MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}; export MAVEN_PROJECTBASEDIR +log "$MAVEN_PROJECTBASEDIR" + +########################################################################################## +# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central +# This allows using the maven wrapper in projects that prohibit checking in binary data. +########################################################################################## +wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" +if [ -r "$wrapperJarPath" ]; then + log "Found $wrapperJarPath" +else + log "Couldn't find $wrapperJarPath, downloading it ..." + + if [ -n "$MVNW_REPOURL" ]; then + wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar" + else + wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar" + fi + while IFS="=" read -r key value; do + # Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' ) + safeValue=$(echo "$value" | tr -d '\r') + case "$key" in (wrapperUrl) wrapperUrl="$safeValue"; break ;; + esac + done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties" + log "Downloading from: $wrapperUrl" + + if $cygwin; then + wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath") + fi + + if command -v wget > /dev/null; then + log "Found wget ... using wget" + [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet" + if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then + wget $QUIET "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath" + else + wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath" + fi + elif command -v curl > /dev/null; then + log "Found curl ... using curl" + [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent" + if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then + curl $QUIET -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath" + else + curl $QUIET --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath" + fi + else + log "Falling back to using Java to download" + javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java" + javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class" + # For Cygwin, switch paths to Windows format before running javac + if $cygwin; then + javaSource=$(cygpath --path --windows "$javaSource") + javaClass=$(cygpath --path --windows "$javaClass") + fi + if [ -e "$javaSource" ]; then + if [ ! -e "$javaClass" ]; then + log " - Compiling MavenWrapperDownloader.java ..." + ("$JAVA_HOME/bin/javac" "$javaSource") + fi + if [ -e "$javaClass" ]; then + log " - Running MavenWrapperDownloader.java ..." + ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath" + fi + fi + fi +fi +########################################################################################## +# End of extension +########################################################################################## + +# If specified, validate the SHA-256 sum of the Maven wrapper jar file +wrapperSha256Sum="" +while IFS="=" read -r key value; do + case "$key" in (wrapperSha256Sum) wrapperSha256Sum=$value; break ;; + esac +done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties" +if [ -n "$wrapperSha256Sum" ]; then + wrapperSha256Result=false + if command -v sha256sum > /dev/null; then + if echo "$wrapperSha256Sum $wrapperJarPath" | sha256sum -c > /dev/null 2>&1; then + wrapperSha256Result=true + fi + elif command -v shasum > /dev/null; then + if echo "$wrapperSha256Sum $wrapperJarPath" | shasum -a 256 -c > /dev/null 2>&1; then + wrapperSha256Result=true + fi + else + echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." + echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties." + exit 1 + fi + if [ $wrapperSha256Result = false ]; then + echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2 + echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2 + echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2 + exit 1 + fi +fi + +MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS" + +# For Cygwin, switch paths to Windows format before running java +if $cygwin; then + [ -n "$JAVA_HOME" ] && + JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME") + [ -n "$CLASSPATH" ] && + CLASSPATH=$(cygpath --path --windows "$CLASSPATH") + [ -n "$MAVEN_PROJECTBASEDIR" ] && + MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR") +fi + +# Provide a "standardized" way to retrieve the CLI args that will +# work with both Windows and non-Windows executions. +MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*" +export MAVEN_CMD_LINE_ARGS + +WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain + +# shellcheck disable=SC2086 # safe args +exec "$JAVACMD" \ + $MAVEN_OPTS \ + $MAVEN_DEBUG_OPTS \ + -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \ + "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \ + ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@" diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw.cmd b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw.cmd new file mode 100644 index 000000000..95ba6f54a --- /dev/null +++ b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/mvnw.cmd @@ -0,0 +1,205 @@ +@REM ---------------------------------------------------------------------------- +@REM Licensed to the Apache Software Foundation (ASF) under one +@REM or more contributor license agreements. See the NOTICE file +@REM distributed with this work for additional information +@REM regarding copyright ownership. The ASF licenses this file +@REM to you under the Apache License, Version 2.0 (the +@REM "License"); you may not use this file except in compliance +@REM with the License. You may obtain a copy of the License at +@REM +@REM https://www.apache.org/licenses/LICENSE-2.0 +@REM +@REM Unless required by applicable law or agreed to in writing, +@REM software distributed under the License is distributed on an +@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +@REM KIND, either express or implied. See the License for the +@REM specific language governing permissions and limitations +@REM under the License. +@REM ---------------------------------------------------------------------------- + +@REM ---------------------------------------------------------------------------- +@REM Apache Maven Wrapper startup batch script, version 3.2.0 +@REM +@REM Required ENV vars: +@REM JAVA_HOME - location of a JDK home dir +@REM +@REM Optional ENV vars +@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands +@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending +@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven +@REM e.g. to debug Maven itself, use +@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 +@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files +@REM ---------------------------------------------------------------------------- + +@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on' +@echo off +@REM set title of command window +title %0 +@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on' +@if "%MAVEN_BATCH_ECHO%" == "on" echo %MAVEN_BATCH_ECHO% + +@REM set %HOME% to equivalent of $HOME +if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%") + +@REM Execute a user defined script before this one +if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre +@REM check for pre script, once with legacy .bat ending and once with .cmd ending +if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %* +if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %* +:skipRcPre + +@setlocal + +set ERROR_CODE=0 + +@REM To isolate internal variables from possible post scripts, we use another setlocal +@setlocal + +@REM ==== START VALIDATION ==== +if not "%JAVA_HOME%" == "" goto OkJHome + +echo. +echo Error: JAVA_HOME not found in your environment. >&2 +echo Please set the JAVA_HOME variable in your environment to match the >&2 +echo location of your Java installation. >&2 +echo. +goto error + +:OkJHome +if exist "%JAVA_HOME%\bin\java.exe" goto init + +echo. +echo Error: JAVA_HOME is set to an invalid directory. >&2 +echo JAVA_HOME = "%JAVA_HOME%" >&2 +echo Please set the JAVA_HOME variable in your environment to match the >&2 +echo location of your Java installation. >&2 +echo. +goto error + +@REM ==== END VALIDATION ==== + +:init + +@REM Find the project base dir, i.e. the directory that contains the folder ".mvn". +@REM Fallback to current working directory if not found. + +set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR% +IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir + +set EXEC_DIR=%CD% +set WDIR=%EXEC_DIR% +:findBaseDir +IF EXIST "%WDIR%"\.mvn goto baseDirFound +cd .. +IF "%WDIR%"=="%CD%" goto baseDirNotFound +set WDIR=%CD% +goto findBaseDir + +:baseDirFound +set MAVEN_PROJECTBASEDIR=%WDIR% +cd "%EXEC_DIR%" +goto endDetectBaseDir + +:baseDirNotFound +set MAVEN_PROJECTBASEDIR=%EXEC_DIR% +cd "%EXEC_DIR%" + +:endDetectBaseDir + +IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig + +@setlocal EnableExtensions EnableDelayedExpansion +for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a +@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS% + +:endReadAdditionalConfig + +SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe" +set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar" +set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain + +set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar" + +FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO ( + IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B +) + +@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central +@REM This allows using the maven wrapper in projects that prohibit checking in binary data. +if exist %WRAPPER_JAR% ( + if "%MVNW_VERBOSE%" == "true" ( + echo Found %WRAPPER_JAR% + ) +) else ( + if not "%MVNW_REPOURL%" == "" ( + SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar" + ) + if "%MVNW_VERBOSE%" == "true" ( + echo Couldn't find %WRAPPER_JAR%, downloading it ... + echo Downloading from: %WRAPPER_URL% + ) + + powershell -Command "&{"^ + "$webclient = new-object System.Net.WebClient;"^ + "if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^ + "$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^ + "}"^ + "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^ + "}" + if "%MVNW_VERBOSE%" == "true" ( + echo Finished downloading %WRAPPER_JAR% + ) +) +@REM End of extension + +@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file +SET WRAPPER_SHA_256_SUM="" +FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO ( + IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B +) +IF NOT %WRAPPER_SHA_256_SUM%=="" ( + powershell -Command "&{"^ + "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^ + "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^ + " Write-Output 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^ + " Write-Output 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^ + " Write-Output 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^ + " exit 1;"^ + "}"^ + "}" + if ERRORLEVEL 1 goto error +) + +@REM Provide a "standardized" way to retrieve the CLI args that will +@REM work with both Windows and non-Windows executions. +set MAVEN_CMD_LINE_ARGS=%* + +%MAVEN_JAVA_EXE% ^ + %JVM_CONFIG_MAVEN_PROPS% ^ + %MAVEN_OPTS% ^ + %MAVEN_DEBUG_OPTS% ^ + -classpath %WRAPPER_JAR% ^ + "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^ + %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %* +if ERRORLEVEL 1 goto error +goto end + +:error +set ERROR_CODE=1 + +:end +@endlocal & set ERROR_CODE=%ERROR_CODE% + +if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost +@REM check for post script, once with legacy .bat ending and once with .cmd ending +if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat" +if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd" +:skipRcPost + +@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on' +if "%MAVEN_BATCH_PAUSE%"=="on" pause + +if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE% + +cmd /C exit /B %ERROR_CODE% diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/pom.xml b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/pom.xml new file mode 100644 index 000000000..acd278760 --- /dev/null +++ b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-postgresql/pom.xml @@ -0,0 +1,48 @@ + + + 4.0.0 + + + org.springframework.boot + spring-boot-starter-parent + 3.2.2 + + + + boot-sql + + + 17 + + + + + + org.springframework.boot + spring-boot-starter + + + + org.springframework.boot + spring-boot-starter-json + + + + org.springframework.boot + spring-boot-starter-web + + + + org.springframework.boot + spring-boot-starter-data-jpa + + + + org.postgresql + postgresql + runtime + + + + + diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.jar b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.jar deleted file mode 100644 index cb28b0e37c7d206feb564310fdeec0927af4123a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 62547 zcmb5V1CS=sk~Z9!wr$(CZEL#U=Co~N+O}=mwr$(Cds^S@-Tij=#=rmlVk@E|Dyp8$ z$UKz?`Q$l@GN3=8fq)=^fVx`E)Pern1@-q?PE1vZPD);!LGdpP^)C$aAFx&{CzjH` zpQV9;fd0PyFPNN=yp*_@iYmRFcvOrKbU!1a*o)t$0ex(~3z5?bw11HQYW_uDngyer za60w&wz^`W&Z!0XSH^cLNR&k>%)Vr|$}(wfBzmSbuK^)dy#xr@_NZVszJASn12dw; z-KbI5yz=2awY0>OUF)&crfPu&tVl|!>g*#ur@K=$@8N05<_Mldg}X`N6O<~3|Dpk3 zRWb!e7z<{Mr96 z^C{%ROigEIapRGbFA5g4XoQAe_Y1ii3Ci!KV`?$ zZ2Hy1VP#hVp>OOqe~m|lo@^276Ik<~*6eRSOe;$wn_0@St#cJy}qI#RP= zHVMXyFYYX%T_k3MNbtOX{<*_6Htq*o|7~MkS|A|A|8AqKl!%zTirAJGz;R<3&F7_N z)uC9$9K1M-)g0#}tnM(lO2k~W&4xT7gshgZ1-y2Yo-q9Li7%zguh7W#kGfnjo7Cl6 z!^wTtP392HU0aVB!$cPHjdK}yi7xNMp+KVZy3_u}+lBCloJ&C?#NE@y$_{Uv83*iV zhDOcv`=|CiyQ5)C4fghUmxmwBP0fvuR>aV`bZ3{Q4&6-(M@5sHt0M(}WetqItGB1C zCU-)_n-VD;(6T1%0(@6%U`UgUwgJCCdXvI#f%79Elbg4^yucgfW1^ zNF!|C39SaXsqU9kIimX0vZ`U29)>O|Kfs*hXBXC;Cs9_Zos3%8lu)JGm~c19+j8Va z)~kFfHouwMbfRHJ``%9mLj_bCx!<)O9XNq&uH(>(Q0V7-gom7$kxSpjpPiYGG{IT8 zKdjoDkkMTL9-|vXDuUL=B-K)nVaSFd5TsX0v1C$ETE1Ajnhe9ept?d;xVCWMc$MbR zL{-oP*vjp_3%f0b8h!Qija6rzq~E!#7X~8^ZUb#@rnF~sG0hx^Ok?G9dwmit494OT z_WQzm_sR_#%|I`jx5(6aJYTLv;3U#e@*^jms9#~U`eHOZZEB~yn=4UA(=_U#pYn5e zeeaDmq-$-)&)5Y}h1zDbftv>|?GjQ=)qUw*^CkcAG#o%I8i186AbS@;qrezPCQYWHe=q-5zF>xO*Kk|VTZD;t={XqrKfR|{itr~k71VS?cBc=9zgeFbpeQf*Wad-tAW7(o ze6RbNeu31Uebi}b0>|=7ZjH*J+zSj8fy|+T)+X{N8Vv^d+USG3arWZ?pz)WD)VW}P z0!D>}01W#e@VWTL8w1m|h`D(EnHc*C5#1WK4G|C5ViXO$YzKfJkda# z2c2*qXI-StLW*7_c-%Dws+D#Kkv^gL!_=GMn?Y^0J7*3le!!fTzSux%=1T$O8oy8j z%)PQ9!O+>+y+Dw*r`*}y4SpUa21pWJ$gEDXCZg8L+B!pYWd8X;jRBQkN_b=#tb6Nx zVodM4k?gF&R&P=s`B3d@M5Qvr;1;i_w1AI=*rH(G1kVRMC`_nohm~Ie5^YWYqZMV2<`J* z`i)p799U_mcUjKYn!^T&hu7`Lw$PkddV&W(ni)y|9f}rGr|i-7nnfH6nyB$Q{(*Nv zZz@~rzWM#V@sjT3ewv9c`pP@xM6D!StnV@qCdO${loe(4Gy00NDF5&@Ku;h2P+Vh7 z(X6De$cX5@V}DHXG?K^6mV>XiT768Ee^ye&Cs=2yefVcFn|G zBz$~J(ld&1j@%`sBK^^0Gs$I$q9{R}!HhVu|B@Bhb29PF(%U6#P|T|{ughrfjB@s- zZ)nWbT=6f6aVyk86h(0{NqFg#_d-&q^A@E2l0Iu0(C1@^s6Y-G0r32qll>aW3cHP# zyH`KWu&2?XrIGVB6LOgb+$1zrsW>c2!a(2Y!TnGSAg(|akb#ROpk$~$h}jiY&nWEz zmMxk4&H$8yk(6GKOLQCx$Ji-5H%$Oo4l7~@gbHzNj;iC%_g-+`hCf=YA>Z&F)I1sI z%?Mm27>#i5b5x*U%#QE0wgsN|L73Qf%Mq)QW@O+)a;#mQN?b8e#X%wHbZyA_F+`P%-1SZVnTPPMermk1Rpm#(;z^tMJqwt zDMHw=^c9%?#BcjyPGZFlGOC12RN(i`QAez>VM4#BK&Tm~MZ_!#U8PR->|l+38rIqk zap{3_ei_txm=KL<4p_ukI`9GAEZ+--)Z%)I+9LYO!c|rF=Da5DE@8%g-Zb*O-z8Tv zzbvTzeUcYFgy{b)8Q6+BPl*C}p~DiX%RHMlZf;NmCH;xy=D6Ii;tGU~ zM?k;9X_E?)-wP|VRChb4LrAL*?XD6R2L(MxRFolr6GJ$C>Ihr*nv#lBU>Yklt`-bQ zr;5c(o}R!m4PRz=CnYcQv}m?O=CA(PWBW0?)UY)5d4Kf;8-HU@=xMnA#uw{g`hK{U zB-EQG%T-7FMuUQ;r2xgBi1w69b-Jk8Kujr>`C#&kw-kx_R_GLRC}oum#c{je^h&x9 zoEe)8uUX|SahpME4SEog-5X^wQE0^I!YEHlwawJ|l^^0kD)z{o4^I$Eha$5tzD*A8 zR<*lss4U5N*JCYl;sxBaQkB3M8VT|gXibxFR-NH4Hsmw|{={*Xk)%!$IeqpW&($DQ zuf$~fL+;QIaK?EUfKSX;Gpbm8{<=v#$SrH~P-it--v1kL>3SbJS@>hAE2x_k1-iK# zRN~My-v@dGN3E#c!V1(nOH>vJ{rcOVCx$5s7B?7EKe%B`bbx(8}km#t2a z1A~COG(S4C7~h~k+3;NkxdA4gbB7bRVbm%$DXK0TSBI=Ph6f+PA@$t){_NrRLb`jp zn1u=O0C8%&`rdQgO3kEi#QqiBQcBcbG3wqPrJ8+0r<`L0Co-n8y-NbWbx;}DTq@FD z1b)B$b>Nwx^2;+oIcgW(4I`5DeLE$mWYYc7#tishbd;Y!oQLxI>?6_zq7Ej)92xAZ z!D0mfl|v4EC<3(06V8m+BS)Vx90b=xBSTwTznptIbt5u5KD54$vwl|kp#RpZuJ*k) z>jw52JS&x)9&g3RDXGV zElux37>A=`#5(UuRx&d4qxrV<38_w?#plbw03l9>Nz$Y zZS;fNq6>cGvoASa2y(D&qR9_{@tVrnvduek+riBR#VCG|4Ne^w@mf2Y;-k90%V zpA6dVw|naH;pM~VAwLcQZ|pyTEr;_S2GpkB?7)+?cW{0yE$G43`viTn+^}IPNlDo3 zmE`*)*tFe^=p+a{a5xR;H0r=&!u9y)kYUv@;NUKZ)`u-KFTv0S&FTEQc;D3d|KEKSxirI9TtAWe#hvOXV z>807~TWI~^rL?)WMmi!T!j-vjsw@f11?#jNTu^cmjp!+A1f__Dw!7oqF>&r$V7gc< z?6D92h~Y?faUD+I8V!w~8Z%ws5S{20(AkaTZc>=z`ZK=>ik1td7Op#vAnD;8S zh<>2tmEZiSm-nEjuaWVE)aUXp$BumSS;qw#Xy7-yeq)(<{2G#ap8z)+lTi( ziMb-iig6!==yk zb6{;1hs`#qO5OJQlcJ|62g!?fbI^6v-(`tAQ%Drjcm!`-$%Q#@yw3pf`mXjN>=BSH z(Nftnf50zUUTK;htPt0ONKJq1_d0!a^g>DeNCNpoyZhsnch+s|jXg1!NnEv%li2yw zL}Y=P3u`S%Fj)lhWv0vF4}R;rh4&}2YB8B!|7^}a{#Oac|%oFdMToRrWxEIEN<0CG@_j#R4%R4i0$*6xzzr}^`rI!#y9Xkr{+Rt9G$*@ zQ}XJ+_dl^9@(QYdlXLIMI_Q2uSl>N9g*YXMjddFvVouadTFwyNOT0uG$p!rGF5*`1 z&xsKPj&;t10m&pdPv+LpZd$pyI_v1IJnMD%kWn{vY=O3k1sJRYwPoDV1S4OfVz4FB z$^ygjgHCW=ySKSsoSA&wSlq83JB+O-)s>>e@a{_FjB{@=AlrX7wq>JE=n@}@fba(;n4EG| zge1i)?NE@M@DC5eEv4; z#R~0aNssmFHANL@-eDq2_jFn=MXE9y>1FZH4&v<}vEdB6Kz^l)X%%X@E#4)ahB(KY zx8RH+1*6b|o1$_lRqi^)qoLs;eV5zkKSN;HDwJIx#ceKS!A$ZJ-BpJSc*zl+D~EM2 zm@Kpq2M*kX`;gES_Dd1Y#UH`i!#1HdehqP^{DA-AW^dV(UPu|O@Hvr>?X3^~=1iaRa~AVXbj z-yGL<(5}*)su2Tj#oIt+c6Gh}$0|sUYGGDzNMX+$Oi$e&UJt3&kwu)HX+XP{es(S3 z%9C9y({_fu>^BKjI7k;mZ4DKrdqxw`IM#8{Sh?X(6WE4S6-9M}U0&e32fV$2w{`19 zd=9JfCaYm@J$;nSG3(|byYDqh>c%`JW)W*Y0&K~g6)W?AvVP&DsF_6!fG3i%j^Q>R zR_j5@NguaZB{&XjXF+~6m|utO*pxq$8?0GjW0J-e6Lnf0c@}hvom8KOnirhjOM7!n zP#Iv^0_BqJI?hR5+Dl}p!7X}^NvFOCGvh9y*hgik<&X)3UcEBCdUr$Dt8?0f&LSur ze*n!(V(7umZ%UCS>Hf(g=}39OcvGbf2+D;OZ089m_nUbdCE0PXJfnyrIlLXGh2D!m zK=C#{JmoHY1ws47L0zeWkxxV=A%V8a&E^w%;fBp`PN_ndicD@oN?p?Bu~20>;h;W` ztV=hI*Ts$6JXOwOY?sOk_1xjzNYA#40dD}|js#3V{SLhPEkn5>Ma+cGQi*#`g-*g56Q&@!dg)|1YpLai3Bu8a;l2fnD6&)MZ~hS%&J}k z2p-wG=S|5YGy*Rcnm<9VIVq%~`Q{g(Vq4V)CP257v06=M2W|8AgZO0CC_}HVQ>`VU zy;2LDlG1iwIeMj?l40_`21Qsm?d=1~6f4@_&`lp~pIeXnR)wF0z7FH&wu~L~mfmMr zY4_w6tc{ZP&sa&Ui@UxZ*!UovRT})(p!GtQh~+AMZ6wcqMXM*4r@EaUdt>;Qs2Nt8 zDCJi#^Rwx|T|j_kZi6K!X>Ir%%UxaH>m6I9Yp;Sr;DKJ@{)dz4hpG>jX?>iiXzVQ0 zR$IzL8q11KPvIWIT{hU`TrFyI0YQh`#>J4XE*3;v^07C004~FC7TlRVVC}<}LC4h_ zZjZ)2*#)JyXPHcwte!}{y%i_!{^KwF9qzIRst@oUu~4m;1J_qR;Pz1KSI{rXY5_I_ z%gWC*%bNsb;v?>+TbM$qT`_U8{-g@egY=7+SN#(?RE<2nfrWrOn2OXK!ek7v`aDrH zxCoFHyA&@^@m+#Y(*cohQ4B76me;)(t}{#7?E$_u#1fv)vUE5K;jmlgYI0$Mo!*EA zf?dx$4L(?nyFbv|AF1kB!$P_q)wk1*@L0>mSC(A8f4Rgmv1HG;QDWFj<(1oz)JHr+cP|EPET zSD~QW&W(W?1PF-iZ()b|UrnB(#wG^NR!*X}t~OS-21dpXq)h)YcdA(1A`2nzVFax9rx~WuN=SVt`OIR=eE@$^9&Gx_HCfN= zI(V`)Jn+tJPF~mS?ED7#InwS&6OfH;qDzI_8@t>In6nl zo}q{Ds*cTG*w3CH{Mw9*Zs|iDH^KqmhlLp_+wfwIS24G z{c@fdgqy^Y)RNpI7va^nYr9;18t|j=AYDMpj)j1oNE;8+QQ)ap8O??lv%jbrb*a;} z?OvnGXbtE9zt;TOyWc|$9BeSGQbfNZR`o_C!kMr|mzFvN+5;g2TgFo8DzgS2kkuw@ z=`Gq?xbAPzyf3MQ^ZXp>Gx4GwPD))qv<1EreWT!S@H-IpO{TPP1se8Yv8f@Xw>B}Y z@#;egDL_+0WDA)AuP5@5Dyefuu&0g;P>ro9Qr>@2-VDrb(-whYxmWgkRGE(KC2LwS z;ya>ASBlDMtcZCCD8h+Awq1%A|Hbx)rpn`REck#(J^SbjiHXe-jBp!?>~DC7Wb?mC z_AN+^nOt;3tPnaRZBEpB6s|hCcFouWlA{3QJHP!EPBq1``CIsgMCYD#80(bsKpvwO)0#)1{ zos6v&9c=%W0G-T@9sfSLxeGZvnHk$SnHw57+5X4!u1dvH0YwOvuZ7M^2YOKra0dqR zD`K@MTs(k@h>VeI5UYI%n7#3L_WXVnpu$Vr-g}gEE>Y8ZQQsj_wbl&t6nj{;ga4q8SN#Z6cBZepMoyv7MF-tnnZp*(8jq848yZ zsG_fP$Y-rtCAPPI7QC^nzQjlk;p3tk88!1dJuEFZ!BoB;c!T>L>xSD<#+4X%*;_IB z0bZ%-SLOi5DV7uo{z}YLKHsOHfFIYlu8h(?gRs9@bbzk&dkvw*CWnV;GTAKOZfbY9 z(nKOTQ?fRRs(pr@KsUDq@*P`YUk4j=m?FIoIr)pHUCSE84|Qcf6GucZBRt;6oq_8Z zP^R{LRMo?8>5oaye)Jgg9?H}q?%m@2bBI!XOOP1B0s$%htwA&XuR`=chDc2)ebgna zFWvevD|V882V)@vt|>eeB+@<-L0^6NN%B5BREi8K=GwHVh6X>kCN+R3l{%oJw5g>F zrj$rp$9 zhepggNYDlBLM;Q*CB&%w zW+aY{Mj{=;Rc0dkUw~k)SwgT$RVEn+1QV;%<*FZg!1OcfOcLiF@~k$`IG|E8J0?R2 zk?iDGLR*b|9#WhNLtavx0&=Nx2NII{!@1T78VEA*I#65C`b5)8cGclxKQoVFM$P({ zLwJKo9!9xN4Q8a2F`xL&_>KZfN zOK?5jP%CT{^m4_jZahnn4DrqgTr%(e_({|z2`C2NrR6=v9 z*|55wrjpExm3M&wQ^P?rQPmkI9Z9jlcB~4IfYuLaBV95OGm#E|YwBvj5Z}L~f`&wc zrFo!zLX*C{d2}OGE{YCxyPDNV(%RZ7;;6oM*5a>5LmLy~_NIuhXTy-*>*^oo1L;`o zlY#igc#sXmsfGHA{Vu$lCq$&Ok|9~pSl5Q3csNqZc-!a;O@R$G28a@Sg#&gnrYFsk z&OjZtfIdsr%RV)bh>{>f883aoWuYCPDP{_)%yQhVdYh;6(EOO=;ztX1>n-LcOvCIr zKPLkb`WG2;>r)LTp!~AlXjf-Oe3k`Chvw$l7SB2bA=x3s$;;VTFL0QcHliysKd^*n zg-SNbtPnMAIBX7uiwi&vS)`dunX$}x)f=iwHH;OS6jZ9dYJ^wQ=F#j9U{wJ9eGH^#vzm$HIm->xSO>WQ~nwLYQ8FS|?l!vWL<%j1~P<+07ZMKkTqE0F*Oy1FchM z2(Nx-db%$WC~|loN~e!U`A4)V4@A|gPZh`TA18`yO1{ z(?VA_M6SYp-A#%JEppNHsV~kgW+*Ez=?H?GV!<$F^nOd+SZX(f0IoC#@A=TDv4B2M z%G-laS}yqR0f+qnYW_e7E;5$Q!eO-%XWZML++hz$Xaq@c%2&ognqB2%k;Cs!WA6vl z{6s3fwj*0Q_odHNXd(8234^=Asmc0#8ChzaSyIeCkO(wxqC=R`cZY1|TSK)EYx{W9 z!YXa8GER#Hx<^$eY>{d;u8*+0ocvY0f#D-}KO!`zyDD$%z1*2KI>T+Xmp)%%7c$P< zvTF;ea#Zfzz51>&s<=tS74(t=Hm0dIncn~&zaxiohmQn>6x`R+%vT%~Dhc%RQ=Cj^ z&%gxxQo!zAsu6Z+Ud#P!%3is<%*dJXe!*wZ-yidw|zw|C`cR z`fiF^(yZt?p{ZX|8Ita)UC$=fg6wOve?w+8ww|^7OQ0d zN(3dmJ@mV8>74I$kQl8NM%aC+2l?ZQ2pqkMs{&q(|4hwNM z^xYnjj)q6uAK@m|H$g2ARS2($e9aqGYlEED9sT?~{isH3Sk}kjmZ05Atkgh^M6VNP zX7@!i@k$yRsDK8RA1iqi0}#Phs7y(bKYAQbO9y=~10?8cXtIC4@gF#xZS;y3mAI`h zZ^VmqwJ%W>kisQ!J6R?Zjcgar;Il%$jI*@y)B+fn^53jQd0`)=C~w%Lo?qw!q3fVi{~2arObUM{s=q)hgBn64~)W0tyi?(vlFb z>tCE=B1cbfyY=V38fUGN(#vmn1aY!@v_c70}pa(Lrle-(-SH8Nd!emQF zf3kz0cE~KzB%37B24|e=l4)L}g1AF@v%J*A;5F7li!>I0`lfO9TR+ak`xyqWnj5iwJ$>t_vp(bet2p(jRD;5Q9x2*`|FA4#5cfo8SF@cW zeO{H7C0_YJ*P@_BEvm2dB}pUDYXq@G1^Ee#NY9Q`l`$BUXb01#lmQk^{g3?aaP~(* zD;INgi#8TDZ&*@ZKhx$jA^H-H1Lp`%`O{Y{@_o!+7ST}{Ng^P;X>~Bci{|Qdf1{}p z_kK+zL;>D30r6~R?|h!5NKYOi6X&I5)|ME+NG>d9^`hxKpU^)KBOpZiU^ z;|SzGWtbaclC-%9(zR-|q}kB8H&($nsB1LPAkgcm+Qs@cAov{IXxo5PHrH(8DuEMb z3_R#>7^jjGeS7$!`}m8!8$z|)I~{dhd)SvoH9oR9#LjO{{8O&r7w{d9V1z^syn&E6 z{DG0vlQF_Yb3*|>RzVop^{$mWp|%NDYj@4{d*-@O^<(=L=DMFIQHEp-dtz@1Rumd; zadt^4B#(uUyM6aeUJkGl0GfaULpR!2Ql&q$nEV^+SiDptdPbuJ=VJ)`czZ@&HPUuj zc5dSRB&xk)dI~;6N?wkzI}}4K3i%I=EnlKGpPJ9hu?mNzH7|H0j(mN3(ubdaps3GM z1i+9gk=!$mH=L#LRDf4!mXw0;uxSUIXhl|#h*uK+fQPilJc8RCK9GNPt=X^8`*;3$ zBBo77gkGB5F8a8)*OR10nK&~8CEMPVQyhY>i`PS{L^-*WAz$ljtU%zlG1lm%%U4Zw zms0oZR8b|`>4U1X*9JLQQ>m9MF5%ppoafz^;`7DbmmIENrc$hucekkE4I83WhT%(9 zMaE;f7`g4B#vl(#tNP8$3q{$&oY*oa0HLX6D?xTW3M6f<^{%CK4OE1Pmfue`M6Dh= z&Z-zrq$^xhP%|hU&)(+2KSSpeHgX^0?gRZ5wA8@%%9~@|*Ylux1M{WQ4ekG(T+_b` zb6I)QRGp%fRF)^T?i^j&JDBhfNU9?>Sl6WVMM%S?7< ze|4gaDbPooB=F4Y=>~_+y~Q1{Ox@%q>v+_ZIOfnz5y+qy zhi+^!CE*Lv-}>g^%G=bGLqD(aTN;yHDBH#tOC=X02}QU~Xdme``Wn>N>6{VwgU~Z>g+0 zxv0`>>iSfu$baHMw8(^FL6QWe;}(U>@;8j)t)yHAOj?SdeH;evFx-kpU@nT>lsrUt zqhV}2pD^5bC4786guG1`5|fK@pE6xcT#ns)vR|^?A08G62teHaE&p`ZrCBj_Swt*~dVt=5*RK6Y{% zABqK$X59BnrK3r3u=wxklRnA1uh+q`?T0kE1YhvDWF4OY#<(+V|R@R%tdkq2huF(!Ip+EpZF3zr*|9pmKHPo)Cu z;H+^s&`Ql}u=Jt~ZWj`bAw|i-3#7(2WuRU3DU{BW8`?!O?YO1M$*MMTsaEM!5Jyp~ z!gp6yR4$O%wQ8%dyz43ZPeoJwy;o;yg=S0^Y}%|)to>=N^`!3VMf1~}OZ`Dl$q&|w z9$!i3!i1uAgPTuKSWdBrDr*N$g=E#mdqfj*h;Z}OG`{n245+g;IKfdn!&gF2OtHaD zyGDzj@@d2!P(_Ux)3v;1ABTj__{w*kaRF-1YVU`})Acgk?(T*1YqEve3=5)8bkZK* z!Tus*e$h@^u z>#zV0771Bix~r&h2FJ9)%N{>s>?2tk1$bId)1#G;OKgn-U8jUo^AK;Hu)hQEi}swD(264kAS-SBCD$R(Ro0rh8~Le zzRwxbz_JHDbD+hTX15AWmVw!#rC)-zeZahQQmo6FG1)ah3uuyIuTMof}RO!`Y3^Fxn_-G$23RDOh(@NU?r6`*S?#E50)w zpcsgDZ-iO{;EesgDQq9;p*C#QH(sp~2w^zAJWaUL%@yo)iIL6y8;e_}=dwQc%k%;H zFt5lenH*`}LWd+fPqi;exJeRZgl&nLR%|a!%1x0RQ54cgyWBYrL>sskcAtPxi&8c( zw_K?sI*3n%S;lKiYpveBN08{rgV&-B1NN5Jiu07~%n#%&f!(R(z1)xsxtRBkg#+Lv zh21zX?aYDd_f}qdA`Os*j!eC<5)iUJ&Twj7?*p%vEOGElGhpRZsccM!<k}DeC;TY;rULQs3e}lZyP#UVb=6 zB$Dkm2FaHWUXr7<{R&46sfZ)&(HXxB_=e`%LZci`s7L6c-L7iF&wdmTJz`*^=jD~* zpOZ@jcq8LezVkE^M6D9^QgZqnX&x*mr1_Cf#R9R3&{i3%v#}V$UZzGC;Or*=Dw5SXBC6NV|sGZp^#%RTimyaj@!ZuyJ z6C+r}O1TsAzV9PAa*Gd!9#FQMl)ZLHzTr99biAqA(dz-m9LeIeKny3YB=*+|#-Gq# zaErUR5Z*Wh^e<+wcm70eW;f-g=YTbMiDX)AznDM6B73)T4r%nq+*hKcKF?)#vbv?K zPMe=sFCuC*ZqsBPh-?g!m*O`}6<}Pfj}Y1n9|Y@cUdD5GX_)6Sx9pPfS7 zxkt?g6ZwJ+50C7qrh6dMFmr7qah`FskT_H=GC92vkVh$WfZa2%5L99_DxyM{$#6HQ zx$VR-Wwt!q9JL2{ybEGJr$^?!V4m_BqDqt!mbs=QjHf340+^a{)waVvP0+98(BA$M ztWr&sM=juyYgvf`(SC}+y@QtYgU>0ghJ6VbU}|kEraR&&W%#;!#KI?le%g`e>ZVPiDrneh#&1(Y?uiMo^f5qo@{JEr(p9>8GhDa+PC9yG;lX+D?hQ^fZB&Sdox219zUj_5;+n<0@Wi3@DK`MU8FM!OFJ z8*_mTA-u!Ab#95FRVWTIqAL#BVQGxE_s?>Ql|@0o9vos&r<_4d!+Q6(_270)6#lu$ zV!j$a?_V0I<(3Z=J7C-K0a^Kc1Go9p&T6yQeAD+)dG-$a&%Fo0AOte~_Z&_m2@ue~ z9cKFf-A41Dz31Ooj9FSR`l?H5UtdP?JS=UU$jF#znE1k@0g%K?KQuwZkfDI3Ai)(q z#x_Yo6WR_Y@#6I_02S&NpcP<%sw!!M_3#*8qa+*4rS@x=i{-2K#*Qr)*Q$-{<_(<| z0730e+rubnT38*m;|$-4!1r6u&Ua2kO_s-(7*NGgDTe##%I>_9uW;X__b_k)xlv$; zW%K2hsmr>5e^Z~`tS-eUgWmSF9}Yg8E}qydSVX0nYZMX_x94QK?tw2>^;raVTqstR zIrNAX2`X~|h->dTOb9IrA!i5INpLV}99ES|i0ldzC`;R$FBY5&7+TIy8%GO8SZ37_ zw=^Swk?z+j-&0-cTE|LU0q@IKRa&C6ZlXbSa2vN5r-)*f<3{wLV*uJUw980AFkWN7 zKh{?97GmVu-0rs9FB6ludy|n`gN5p~?y51aJzBg6#+-=0pWdZ2n4xTiQ=&3As-!-6 zFlb|ssAJEJL#s8(=odfz8^9b#@RrvNE4gjuEITzAd7R4+rq$yEJKXP?6D@yM7xZ&^ z@%jnE3}bteJo{p(l`hu`Yvzg9I#~>(T;>c;ufeLfc!m3D&RaQS=gAtEO-WbI+f_#| zaVpq-<%~=27U8*qlVCuI6z9@j)#R!z3{jc>&I(qT-8IBW57_$z5Qm3gVC1TcWJNc% zDk?H3%QHno@fu9nT%L^K)=#sRiRNg|=%M zR;8BE)QA4#Dsg^EakzttRg9pkfIrF3iVYVM#*_+#3X+~qeZc^WQJvEyVlO@9=0pl!ayNOh|{j0j^a z+zi_$_0QKhwArW)sJ$wji;A`?$ecbr?(4x5%2pLgh#wggbt)#T^2R3a9m+>GcrUxU z*u-WTgHAN*e!0;Wa%1k)J_P(Vdp>vwrROTVae@6Wn04q4JL-)g&bWO6PWGuN2Q*s9 zn47Q2bIn4=!P1k0jN_U#+`Ah59zRD??jY?s;U;k@%q87=dM*_yvLN0->qswJWb zImaj{Ah&`)C$u#E0mfZh;iyyWNyEg;w0v%QS5 zGXqad{`>!XZJ%+nT+DiVm;lahOGmZyeqJ-;D&!S3d%CQS4ZFM zkzq5U^O|vIsU_erz_^^$|D0E3(i*&fF-fN}8!k3ugsUmW1{&dgnk!|>z2At?h^^T@ zWN_|`?#UM!FwqmSAgD6Hw%VM|fEAlhIA~^S@d@o<`-sxtE(|<><#76_5^l)Xr|l}Q zd@7Fa8Bj1ICqcy2fKl1rD4TYd84)PG5Ee2W4Nt@NNmpJWvc3q@@*c;~%^Vasf2H`y z+~U-19wtFT?@yIFc4SE_ab?s@wEUfSkOED}+qVjjy>=eac2^S^+|_3%cjH%EUTJ&r znp9q?RbStJcT*Vi{3KDa^jr4>{5x+?!1)8c2SqiCEzE$TQ+`3KPQQnG8_Qk<^)y_o zt1Q^f{#yCUt!1e(3;E6y?>p+7sGAYLp`lA3c~Y`re9q&`c6>0?c0E2Ap5seFv92#X z1Vldj!7A8@8tWr&?%;EBQ_Fwd)8A3!wIx`V!~~h(!$pCy7=&*+*uIzG@*d%*{qG#4 zX0^}}sRN^N=p{w(+yjv%xwb!%lnVTE7l1l6gJwQmq_G83J&Y98$S!r*L8}IiIa2E= zE!0tbOuEDb*No0-KB{zjo1k#_4FHtr{!)>o+Y@bll}Sa6D^xktI0H&l{jKAK)A(iz zB-N00F?~Z}Y7tG+vp)-q*v71(C}65$-=uXx^|R$xx9zZip-V>Hqeyfd(wteM)+!!H z$s+>g4I@+`h2>C|J;PhvtOq)`xm4;CyF}R<)!ma3T{Vf_5|zo;D4YI4ZDBkE(vMeE zb#ZV;n}CgA0w8x!UC2&5Z(K)9bibj#?~>R(72lFx_Am~jS?;7mo~p+05~XGD+(wV4 zEVYnf0N5+-7O+Gc1L!sPGUHv<6=cV8}*m$m`kBs@z zy;goR(?J^JrB7uXXpD00+SD0luk!vK3wwp(N%|X!HmO{xC#OMYQ&a7Yqv-54iEUK4 zVH;)rY6)pUX~ESvQK^w|&}>J{I?YlvOhpMgt-JB}m5Br`Q9X+^8+Xa%S81hO<1t#h zbS+MljFP1J0GGNR1}KwE=cfey%;@n&@Kli+Z5d>daJjbvuO3dW{r$1FT0j zR$c9$t~P50P+NhG^krLH%k}wsQ%mm+@#c;-c9>rYy;8#(jZ|KA8RrmnN2~>w0ciU7 zGiLC?Q^{^Ox-9F()RE^>Xq(MAbGaT0^6jc>M5^*&uc@YGt5Iw4i{6_z5}H$oO`arY z4BT(POK%DnxbH>P$A;OWPb@gYS96F7`jTn6JO@hdM za>_p!1mf?ULJZb1w-+HamqN__2CtI%VK`k^(++Ga0%z*z@k0wYJDqT^)~%|4O299; zh1_iRtc7you(kOK8?Q$R7v-@Qk4+i=8GD2_zI0%{Ra`_prF{+UPW^m5MCA&4ZUpZb z2*!)KA8b--Upp~U%f+rsmCmV~!Y>Gzl#yVvZER2h;f&rkdx{r#9mc8DZMJaQXs?SL zCg3#>xR6ve8&YkP*`Z=lng|Ow+h@t*!Ial*XQg3P;VS8@E1C)VS`?L9N+rxlD7bxC z3@Ag)Vu?#ykY`ND+GvRYTUP&-KDMiqly$Z~uFXt^)4Jjk9RIs*&$?-UPM*d7&m${m zm12kaN3mV1J|c6f$>V+{lvHp~XVW3DU0;cBR>7|)4bo{xa1-ts-lYU-Q-b)_fVVl`EP5X}+J9EzT20x8XIv=m7witdu7!3Lh=KE#OyKpT1GWk{YAo^ny|fvZt<+jmsFs=l*%e& zmRkBt5ccv4O7!HAyv2~rsq*(FmMTm?@TX3&1`nu|7C^F{ad%GLuoX}Rl}6`)uHF_xlx^gVca+mGH4T8u8;q{S*x3=j;kelz^atO~)v!Q_BT z4H6%IA}bvfuk0_vweELeEl8N5w-Q1GF!@f{VKnbyYB2?}d&QvI-j}~RI_+9t9$tC2 z94m=3eLi=sQb^S5;fqP?3aaXc&`}`lq z&M8dOXvxx9Y1^u_ZQHhO+qP}nwkvJhwoz$Mp6Qcq^7M#eWm}!3U@s07hop` zW24|J{t$aB`W>uBTssEvYMyi$hkaOqWh+^(RV_1MYnE0XPgW?7sBDk=Cqs(;$qrPEflqa0ZE?A3cBfW%0RPA235Wb6@=R_d>Sez; z`spwa50bq?-zh+id~Q!T`AYn`$GHzs;jxIw(A1_Ql&f|qP}|bon#H;sjKmSDM!nyn z>bU8l%3DB3F+$}|J^da!!pN|DO!Ndc2J)wMk!+Rr1hes#V}5o(?(yQSphn|9_aU<- zn|nsDS{^x&tweP;Ft`2ur>Koo2IdXJDsr6IN)7vB41Yy-^Wbo9*2th2QA@C zE0-0Gk12YOO?d_Guu6b3&(PIL`d zh4{`k54hu9o%v1K3PGuccez-wdC<&2fp)>`qIIaf)R{5un7-vwm=>LD7ibnJ$|KyE zzw`X*tM0S|V(I3vf454PY{yA5lbE+36_<1kd=&0Xy4jfvUKZ0$Jq!AG4KS7DrE9rph;dK^6*#CIU9qu7 z?)6O`TN&MCWGmUVd1@E2ow2`vZ1A#nGo8_n!dmX77DCgAP1va*ILU+!a&$zdm6Pa6 z4#|*&3dM+r_RJb%!0}7X!An&T4a4@ejqNJ;=1YVQ{J6|oURuj8MBZ8i7l=zz%S4-; zL}=M^wU43lZVwNJgN|#xIfo$aZfY#odZ6~z?aNn=oR1@zDb=a(o3w`IGu&j>6lYxL z&MtqINe4Z>bdsHNkVIu$Dbq0wc#X-xev221e~L zbm8kJ(Xzij$gF4Ij0(yuR?H1hShSy@{WXsHyKtAedk4O!IdpR{E32Oqp{1TD{usJi zGG@{3A$x%R*pp8b$RQo4w&eDhN`&b~iZ2m3U>@9p1o5kXoEVmHX7I6Uw4dn((mFw` zilWrqFd=F5sH$&*(eJB52zaLwRe zz`sruIc=Ck75>v5P5kd>B2u=drvGPg6s&k5^W!%CDxtRO)V6_Y_QP{%7B>E~vyMLG zhrfn8kijyK&bX+rZsnSJ26!j$1x+V!Pyn|ph%sXWr9^f&lf|C;+I^Fi_4;`-LJI&F zr;5O@#4jZX=Yaw0`pUyfF4J8A9wE#7_9!X|_s8~YUzWu&#E^%4NxUA3*jK-F5R3LP2|msHBLmiMIzVpPAEX)2 zLKYjm3VI4r#7|nP^}-}rL+Q4?LqlmBnbL+R8P%8VmV{`wP0=~2)LptW_i682*sUR# z+EifOk_cWVKg-iWr^Qf4cs^3&@BFRC6n0vu{HqZzNqW1{m)3K@gi$i}O(hT`f#bT- z8PqCdSj~FncPNmMKl9i9QPH1OMhvd42zLL~qWVup#nIJRg_?7KQ-g3jGTt5ywN;Qx zwmz4dddJYIOsC8VqC2R%NQ>zm=PJH70kS|EsEB>2Otmtf-18`jUGA6kMZL3vEASDN zNX%?0+=vgsUz!dxZ@~)eU17m4pN3xGC0T;#a@b9Iu0g_v*a3|ck^s_DVA^%yH-wt= zm1)7&q6&Rq#)nc9PQ6DKD{NU=&ul10rTiIe!)x^PS~=K(wX9|?k&{Mv&S$iL9@H7= zG0w~UxKXLF003zJ-H%fGA4Db9{~#p&Bl7ki^SWwv2sfoAlrLMvza)uh;7Aa_@FL4b z4G>`j5Mn9e5JrrN#R$wiB(!6@lU@49(tawM&oma6lB$-^!Pmmo;&j57CDmKi)yesg~P;lJPy9D(!;n;^1ql)$5uYf~f z&GywSWx=ABov_%8pCx=g-gww_u26?5st=rdeExu?5dvj^C?ZZxDv@Si^nX~2qA&K= z2jr;{=L(x~9GLXrIGXs>dehU^D}_NMCMegdtNVWyx)8xHT6Qu!R>?%@RvADs9er;NMkweUBFNrBm1F5e0_>^%CwM6ui}K_MpRqLS0*@lAcj zB6TTCBv>w2qh)qU3*kN+6tPmMQx|5Z0A4n67U-nss90Ec_rDF}r)IR4PE{$8;BSt= zT%6|jyD^(w6a*A5>_|TkMqx~e$n@8{`q?|)Q&Y4UWcI!yP-8AwBQ#P`%M&ib;}pli z9KAPU_9txQ3zOM#(x}*lN8q$2(Tq1yT4RN0!t~|&RdQMXfm!81d0ZuyD}aG3r4+g` z8Aevs3E_ssRAMR+&*Q30M!J5&o%^(3$ZJ=PLZ9<@x^0nb>dm17;8EQJE>hLgR(Wc% zn_LXw|5=b$6%X zS~ClDAZ?wdQrtKcV9>_v1_IXqy)?<@cGGq#!H`DNOE1hb4*P_@tGbMy6r@iCN=NiA zL1jLwuMw&N-e9H(v7>HGwqegSgD{GSzZ@sZ?g5Y`fuZ^X2hL=qeFO(;u|QZl1|HmW zYv+kq#fq_Kzr_LaezT zqIkG6R+ve#k6!xy*}@Kz@jcRaG9g|~j5fAYegGOE0k8+qtF?EgI99h*W}Cw z7TP&T0tz4QxiW!r zF4?|!WiNo=$ZCyrom-ep7y}(MVWOWxL+9?AlhX<>p||=VzvX`lUX(EdR^e5m%Rp_q zim6JL6{>S%OKoX(0FS>c1zY|;&!%i-sSE>ybYX3&^>zb`NPj7?N^ydh=s=0fpyyz% zraFILQ17_9<ettJJt~I+sl=&CPHwz zC9dEb#QFQcY?bk11Y=tEl{t+2IG`QFmYS>ECl;kv=N6&_xJLQt>}ZQiFSf+!D*4Ar zGJ~LFB7e_2AQaxg*h{$!eJ6=smO(d2ZNmwzcy3OG@)kNymCWS44|>fP^7QkJHkE9JmLryhcxFASKb4GYkJ|u^Fj=VdF0%6kgKllkt zC|_ov2R4cJ2QjjYjT6jE#J1J<xaNC>Xm;0SX<`LuW*}*{yQ3c9{Zl=<9NP z^2g5rAdO!-b4XfeBrXa4f{M0&VDrq+ps&2C8FYl@S59?edhp~7ee>GR$zQI4r8ONi zP^OA+8zrTAxOMx5ZBS03RS@J_V`3{QsOxznx6Yt*$IuEd3%R|Ki&zZkjNvrxlPD$m z%K+rwM!`E&Z46ogXCu!3 z8use`FJJ?g_xi?~?MxZYXEu=F=XTC8P3{W*CbG3Wk)^31nD~W>*cJ@W4xg%Qqo7rq z`pUu8wL!6Cm~@niI*YmQ+NbldAlQRh?L!)upVZ)|1{2;0gh38FD&8h#V{7tR&&J}I zX1?;dBqK}5XVyv;l(%?@IVMYj3lL4r)Wx9$<99}{B92UthUfHW3DvGth^Q0-=kcJ1 z!*I9xYAc$5N$~rXV>_VzPVv`6CeX(A_j3*ZkeB~lor#8O-k+0OOYzTkri@PVRRpOP zmBV|NKlJT?y4Q82er)@lK&P%CeLbRw8f+ZC9R)twg5ayJ-Va!hbpPlhs?>297lC8 zvD*WtsmSS{t{}hMPS;JjNf)`_WzqoEt~Pd0T;+_0g*?p=dEQ0#Aemzg_czxPUspzI z^H5oelpi$Z{#zG$emQJ#$q#|K%a0_x5`|;7XGMuQ7lQB9zsnh6b75B9@>ZatHR_6c z0(k}`kfHic{V|@;ghTu>UOZ_jFClp>UT#piDniL(5ZNYXWeW0VRfBerxamg4su5<; z(}Ct2AhR@I-ro0}DdZLRtgI@dm+V`cRZjgV-H+aXm5|Mgz`aZX63i<|oHk-E)cABn z0$NR?(>fla7)Ong28FZSi9Yk0LtYl5lZw5wT!K5=fYT$avgkMKJWx~V#i@7~6_{dM zxDDPIW2l{O2Elv#i^cjYg~lGHRj(W*9gD`(FILKY$R`tL2qo&rtU*c;li!V`O$aV{ z!m|n!FAB2>MR_FVN*Ktv5+2dW4rr3YmfEheyD+48%USM#q6)w%#2}~=5yZE1LLcth zF%VtefH&#AcMx7)JNC$P>~OFuG6sK}F7V$D7m!{ixz&inpAVpFXiu^QruAw@Sc7Y2 z_A^V(2W_+KTGRp2aQSMAgyV#b3@{?5q@hPEP6oF3^}|@8GuD6iKbX;!LI!L=P#Za zL$Zuv#=x3fseRMZ()#SQcXv->xW`C|6quwqL1M&KByBj z2V`}(uL4JB-hUs6304@%QL~S6VF^6ZI=e-Nm9Tc^7gWLd*HM-^S&0d1NuObw-Y3e> zqSXR3>u^~aDQx>tHzn9x?XRk}+__h_LvS~3Fa`#+m*MB9qG(g(GY-^;wO|i#x^?CR zVsOitW{)5m7YV{kb&Z!eXmI}pxP_^kI{}#_ zgjaG)(y7RO*u`io)9E{kXo@kDHrbP;mO`v2Hei32u~HxyuS)acL!R(MUiOKsKCRtv z#H4&dEtrDz|MLy<&(dV!`Pr-J2RVuX1OUME@1%*GzLOchqoc94!9QF$QnrTrRzl`K zYz}h+XD4&p|5Pg33fh+ch;6#w*H5`@6xA;;S5)H>i$}ii2d*l_1qHxY`L3g=t? z!-H0J5>kDt$4DQ{@V3$htxCI;N+$d^K^ad8q~&)NCV6wa5(D${P!Y2w(XF!8d0GpJ zRa=xLRQ;=8`J2+A334};LOIhU`HQ*0v4Upn?w|sciL|{AJSrG_(%-(W9EZb%>EAGG zpDY?z1rQLps`nbCtzqJ#@wxU4}(j!ZQ{`g`g*SXlLah*W9 zyuh)UWoRCknQtd~Lk#BT_qjwj&Kw8U)w=owaJ;A5ae}3)y>{neYNS`|VHJdcSEBF# zBJ6a;T)u;^i#L~LVF-X7!E$SggILXMlsEy~v}K*DM2)f@U~g|Q6I-Pss@)`>fgFWx zsq&7pe!|VA-h;@=fBF{(mR1^{1>ukTYUdyF^#A+(|I_&nm{_xaKn3h4&yMyym2k-wMFg(s@ez=DPmuB%`| z6;e@HQKB(|!PU1sW)W6~x|=8m6rL~4dQ9LTk|RzL-_(_77B4I~ZG=q7K%qHiv!FD8 zmt;Vnhb{ymaydv2V;X-5p zTt2ln?kaB9&(dH_X70^@rrCfz)nwfa9LYTHXO(IPcTEf$QiEhTpl??L+`Eetyqof8 zzl=q)?KdYni!C_9b8Z3xm7r5<5ZG-0uA`u^7Dm7k4mAsQ(rkoWy*^DZJa~#y6+hNG zh?7{D9$a9LS`a@SvZ5?C{JUHovWU9KI}z8YV4pWftx21v*Q;MpU{+b@>Or(}pwO^fu0qA3_k_Bo2}lIxvmMhucG-o>O=+R6YxZ zjs!o%K1AA*q#&bs@~%YA@C;}?!7yIml1`%lT3Cvq4)%A)U0o1)7HM;mm4-ZZK2`Lj zLo?!Kq1G1y1lk>$U~_tOW=%XFoyIui^Cdk511&V}x#n4JeB7>bpQkYIkpGQRHxH$L z%tS=WHC~upIXSem>=TTv?BLsQ37AO88(X+L1bI<;Bt>eY!}wjYoBn#2RGEP49&ZH-Z_}R_JK_ z>o*_y!pOI6?Vf*{x-XT;^(_0}2twfk`*)_lLl0H-g|}BC?dm7CU|^-gNJ~rx z($>97WTKf71$?2|V$Ybpf~Aj@ZZOcb3#uRq51%4^ts-#RMrJhgm|K3QpCsPGW=2dZ zAr5-HYX!D*o#Q&2;jL%X?0{}yH}j*(JC4ck;u%=a_D6CrXyBIM&O#7QWgc?@7MCsY zfH6&xgQmG$U6Miu$iF(*6d8Mq3Z+en_Fi`6VFF=i6L8+;Hr6J zmT=k0A2T{9Ghh9@)|G5R-<3A|qe_a#ipsFs6Yd!}Lcdl8k)I22-)F^4O&GP&1ljl~ z!REpRoer@}YTSWM&mueNci|^H?GbJcfC_Y@?Y+e4Yw?Qoy@VLy_8u2d#0W~C6j(pe zyO6SqpGhB-;)%3lwMGseMkWH0EgErnd9a_pLaxbWJug8$meJoY@o-5kNv&A$MJZ=U z^fXPLqV6m3#x%4V*OYD zUPS&WHikdN<{#Yj|EFQ`UojD4`Zh*CZO4Cv`w^&*FfqBi`iXsWg%%a< zk@*c%j1+xib(4q^nHHO^y5d8iNkvczbqZ5;^ZVu%*PJ!O?X-CoNP*&tOU!5%bwUEw zQN?P*a=KKlu{`7GoA}DE=#nDibRgecw>-*da~7&wgow}|DyCJq!-Lp8a~(zR@tO1 zgu(4s4HptPGn(HmN2ayYs@g+yx1n`nU3KM{tQHhMHBw7f#gwru$=C()`aKZAl^dYc ze7fC)8EZEXOryk6AD&-4L+4cJ&M@3;;{R)mi4=`ti7IZByr^|_HNsjcNFu?mIE)jD za2j)FPwRY!R_YR-P?URm0Pti*e#5jmfK)6EvaKCT{h)kbJl{AGr1Ekt}pG?^e z*botRf-RsB8q10BTroj{ZP**)2zkXTF+{9<4@$aNDreO7%tttKkR3z`3ljd?heAJEe<0%4zYK?};Ur*!a>PbGYFFi(OF-%wyzbKeBdbkjv^i9mn@UocSS z4;J%-Q$l`zb&r*Pb`U;3@qkc=8QaPE9KwmlVwAf01sa*uI2*N`9U^3*1lLsM9dJ(4 zZBkU}os|5YT#Z;PD8xVv!yo$-n{-n4JM5ukjnTciniiT`(cZ6sD6~67e5_?8am%!w zeCLUxq~7x-!Xg#PgKV&caC@7mu<86am{WaXo(lAemt4~I$utSp(URWpYNo$RvU*$N z#%iiA+h`(E;BUg;=I!#EaxO89bUK3*v5Nc3GPmURC5TqzC|))DsFNtJICH6oBW6#q z+B(N{ey+^mk_{!@ z)VhAWXG=_0j|0f9iJ;c404PiIFqK)(AD05Xh`Fk`r$^b`v+>*g+_+h@r)e+ELJ45) z?20~u<}HQyQ5AsBz(teF9!!_GLXnm{5Z0e{Ki*@!=&3x4-RcjBn##DDzHJ|KSZ5(E z9=tFZ)p~-}x%9sCY27)2i>(E-^OiYT?_)a;yXAGR$y+E`myMd;xDA#_Q49t*E}&ql#H~|x z2J2R1_#2lt91NnF!uqW%_=HlbF?A{B{n>}9$g5QF!bh_a7LTU~Jyz}7>W5{_LAov{ zy2_dmGy)d)&7^bJyUjEw%3xj{cuG0Eo zwL*XQB*Oi=r&HIIecC1%lbE;Y-*5|cL955S+2@uR18JDL<0;;Uc2Q9JEyo1R!!sz_ z#BqnkGfbLP#oQJk3y}nwMd(3Tt^PVA#zXnYF7D0W1)#+`i?@cm}fBkKD z+Mpcuim53|v7;8Tv(KraEyOK`HvJq^;rlNzOjIbW&HJDFqW>doN&j7)`RDv#v|PQ+ z03WnB4Y4X@Fe-@%3;He*FjY1MFmkyv0>64Cp~FIDKQTwmFP~_CxZOf{8gPy}I<=JC zo%_bmue&$UU0|GG%%99eI!m#5Y1MD3AsJqG#gt3u{%sj5&tQ&xZpP%fcKdYPtr<3$ zAeqgZ=vdjA;Xi##r%!J+yhK)TDP3%C7Y#J|&N^))dRk&qJSU*b;1W%t1;j#2{l~#{ zo8QYEny2AY>N{z4S6|uBzYp>7nP_tqX#!DfgQfeY6CO7ZRJ10&$5Rc+BEPb{ns!Bi z`y;v{>LQheel`}&OniUiNtQv@;EQP5iR&MitbPCYvoZgL76Tqu#lruAI`#g9F#j!= z^FLRVg0?m$=BCaL`u{ZnNKV>N`O$SuDvY`AoyfIzL9~ zo|bs1ADoXMr{tRGL% zA#cLu%kuMrYQXJq8(&qS|UYUxdCla(;SJLYIdQp)1luCxniVg~duy zUTPo9%ev2~W}Vbm-*=!DKv$%TktO$2rF~7-W-{ODp{sL%yQY_tcupR@HlA0f#^1l8 zbi>MV~o zz)zl1a?sGv)E}kP$4v3CQgTjpSJo?s>_$e>s2i+M^D5EfrwjFAo(8E%(^ROV0vz0o z-cg0jIk24n!wxZainfH)+?MGu@kg$XgaMY-^H}z^vG~XC7z2;p2Kv`b^3S#b5ssMOJ7724v>S36dD zeypxJ<=E~sD4f5wX060RIF-AR0#{Z z=&y$r8A-e6q18lIF{@O9Mi%dYSYT6erw!@zrl=uj>o(3=M*Bg4E$#bLhNUPO+Mn}>+IVN-`>5gM7tT7jre|&*_t;Tpk%PJL z%$qScr*q7OJ6?p&;VjEZ&*A;wHv2GdJ+fE;d(Qj#pmf2WL5#s^ZrXYC8x7)>5vq_7 zMCL}T{jNMA5`}6P5#PaMJDB2~TVt;!yEP)WEDAoi9PUt89S2Cj?+E0V(=_sv4Vn6b z_kS6~X!G;PKK>vZF@gWpg8Zuh%YX^2UYPdCg7?EH#^gkdOWpy(%RnXyyrhmJT~UJw zAR;%Zgb6z(mS+o9MT|Sc6O({!i0pzk;s9?Dq)%tTW3*XdM3zhPn*`z45$Bg!P4xfy zD*{>30*JsSk?bQ-DgG62v>Vw-w`SA}{*Za7%N(d-mr@~xq5&OvPa*F2Q3Mqzzf%Oe z4N$`+<=;f5_$9nBd=PhPRU>9_2N8M`tT<-fcvc&!qkoAo4J{e3&;6(YoF8Wd&A+>; z|MSKXb~83~{=byCWHm57tRs{!AI<5papN(zKssb_p_WT@0kL0T0Z5#KLbz%zfk?f7 zR!vXBs36XaNcq5usS7<>skM_*P$e*^8y1ksiuokbsGFQ_{-8BAMfu!Z6G=88;>Fxt z|F-RU{=9i6obkTa0k~L#g;9ot8GCSxjAsyeN~1;^E=o5`m%u7dO1C*nn1gklHCBUw z;R(LgZ}sHld`c%&=S+Vx%;_I1*36P`WYx%&AboA1W@P;BvuFW+ng*wh?^aH4-b7So zG?9kFs_6ma85@wo!Z`L)B#zQAZz{Mc7S%d<*_4cKYaKRSY`#<{w?}4*Z>f2gvK`P1 zfT~v?LkvzaxnV|3^^P5UZa1I@u*4>TdXADYkent$d1q;jzE~%v?@rFYC~jB;IM5n_U0;r>5Xmdu{;2%zCwa&n>vnRC^&+dUZKy zt=@Lfsb$dsMP}Bn;3sb+u76jBKX(|0P-^P!&CUJ!;M?R?z7)$0DXkMG*ccBLj+xI) zYP=jIl88MY5Jyf@wKN--x@We~_^#kM2#Xg$0yD+2Tu^MZ1w%AIpCToT-qQbctHpc_ z>Z97ECB%ak;R<4hEt6bVqgYm(!~^Yx9?6_FUDqQQVk=HETyWpi!O^`EZ_5AoSv@VbUzsqusIZ;yX!4CsMiznO}S{4e>^0`c<)c~mC#*{90@+T@%EQ~>bovc8n_$bvqkOU7CrYe8uI5~{3O7EijeX`js z-$LNz4pJA7_V5~JA_Wl*uSrQYSh9Wm($%@jowv^fSPW<~kK&M*hAleywHd?7v{`;Y zBhL2+-O+7QK_)7XOJAbdTV-S`!I)t~GE8z+fV7y;wp#!wj75drv;R*UdSh(}u$%{VSd0gLeFp;h6FkiVz%g=EY3G#>RU;alRy;vQmk*| z@x-ba0XKE%IyL4OYw6IXzMiS(q^UDk=t(#XgkuF`{P?=k8k3r)rmhkv`vg@kiWd34 z-~t+1aV3SabTbG=nQYs>3~E<}{5@0g**LAWi*~SfRZhGcgP{e5T!0M7CU}`f@r8xI z0bx%sI!?5);-wG+Mx&S=NRfIi>V-wP(n&$X0Bhd)qI^ch%96s6&u7qpiK8ijA=X_R zk&|9f$GXf-;VgnrxV83Cp-Q!!sHH`5O^o~qZu!xny1t?(Au(EAn)D??v<1Uo;#m7-M@ovk|()C(`o>QMTp}F?> zakm3bHBKUjH-MHXDow7#Z|@wea1X9ePH;%YA)fCZ9-MD)p^(p!2E`aU9nmJlm;CXQ zkx~$WQ`Yq{1h5k>E>Ex{Z=P=)N*0b8_O({IeKg?vqQ)hk=JHe z5iqUKm!~mLP0fnRwkCO(xxTV@&p+o8wdSP$jZofYP}yEkvSc z5yD-^>04{zTP7X44q9Af&-wgt7k|XtncO&L@y-wFFR44RsPu57FRvIBaI^Pqy_*DV z@i13CsaR5@X@xH=NT3}T`_vsy!a02n80eQqya=-p7#YW`Jc0z!QglGg`1zeg6uXwI zsB~hlNMo)kFL(V3Q1<%8yoI6X7ncn-&&Uh3rL@S(6@wKAXt6Wr=a2ObI7}8$D-FoI z>AJA>WsBEMi5ba6JhJ%9EAi&ocd(ZsD|MsXwu@X;2h#|(bSWu@2{+c7soC`%uo{sMYq&Vyufb)?OI59ds)O+kyE8@G z@tlpNr0UO~}qd0HQve6njJ zda2+l$gdX7AvvGhxM6OToCuQ|Zw|9!g1)O+7>~{KNvASjp9#Cqce-or+y5xdzWL3gLWt2oa+T(I+{j(&bF1laUsJB{fOgE-B}qslaS>C z)TjzG8XecbS%a+?yT!0QmTex?E478;D|sL*oS4C-g0Tq(YoH|eyxJ#1j088C|U-w5id`%Sz7X_w#l+U9+)$|2no<}5J zRb_9@0esSr?n}HvVGbD5@$p$8k4?qOe-GNOk3-K^Mw>Xg+drCKi5@$GTeijpI;;IG ziD<&go`ptLC&^<0jw^l0aY?_pUUK+xp#0Bk66iQ29vpR)VBE{JOJ&OL^gKsN<&t<| zCMLTYMSDG5Ie9O>6Dl#T{@cscz%)}?tC#?rj>iwQ0!YUk~R z$rB-k=fa9x&631Z9Mfqj_GRoS1MzqSMEdaZ2!isP19Sr>qG8!yL(WWF)_&{F)r>KnJGSciSp!P0fqHr+G=fGO02Q#9gHK zpwz+yhpC4w*<9JO@#(MdkZcWbdCO5B!H`Z|nV?UtcBo96$BgX+7VYMwp@b-%;BrJu zMd*K!{1txv{kHKPDs9?WZrz_^o1Tq2P=+=|E=Oy4#WE{>9}*9(apqhmE`&AeBzQgQ zELFLCmb~q|6y0FCt|B}*uI*ayZ#6=$BpGtF{Jfye#Q>FZ?BPnk)*Qmd?rNG^tvFUU z_b&antYsZnUR6Q9tQUy81r$&ovT#fy;(Db4F&M*C=KxQgHDrRcVR#d+ z0(D|*9#u`w_%2o3faI{?dNd9$#5nj1PROHNq z7HJ(;7B1ThyM>a@Fo^lJb2ls2lD`}ocREH|5pKN;$>gFyM6k)kZG;lA;@kSJIqUhf zX%dhcN(Jtomz4(rNng&1br3Xx33EvCWz%o8s;SpRiKEUFd+KJ+u|gn|J85dZ)Exc&=V|Ns8Xs#P>qv6PX&VAJXJ(ILZO!WJd0 z`+|f5HrEj~isRN7?dBHotcPI7;6W48*%J(9 zftl1Tr`bKH*WNdFx+h;BZ+`p!qKl~|Zt5izh}#pU9FQKE97#$@*pf38Hr8A+`N+50U3$6h%^!4fBN zjh^cl#8qW5OZbvxCfYzKHuyeKLF4z^@~+oqlz9(Hx8vypIiUlt!(vs}_t#4@nh$s; z>FYERg*KD#Xs+W4q-V-IBQK!)M1)Aa+h+V+is)z!_=gEn&^ci7<DEEmYcoSh?WdXUsP7O4)&lQXA(BVM5jI8s6;mO}94AC0gG(`>|T)yuV1l~i-ejCCt zoejDhX0nrZDP|x9u4zp%S2UeDzV`o#pBGu1tZ-$<9TIbN=ALwhQ0=9S{8#}Uu8n-~ z5~xIvUhLSz@c@0|me$CdZCpZl(vQw@a0Y4^{T0w_>pOkwI^x4KkBf3qGmm)nG|Ps5 z_XTY~^b^mL&_*yjl~RRIi&eS(>y?y}O4-)nWyTEPpQAb#Xz8SnnfIL+nAcNL9nqV9 zRL|eyF)RKI5-kJO6}>Q89XmgY@b1&!JI>g3ryZ@jN2v3vm7O`AL!BTWNouJzV+$+Y zYY}u%i>K6=IYU2O$2TAyVjGt?wgF9xCj;?EK(8fWu!!~48`3u^W$eUlCh*91PLxu1 zRY(F7Q3s7h$Q-p&L$ucN}it*-9KR z_<wHu?!dav0$P+PI3{J8?{+l|n&2YMLV2 z+hRta$A5WpCXl1RNbYBsX8IGX{2v>U|8_I-JD56K|GexW>}F_e_g_1r?08v8Kz{V$ zT=6aGMk>ibvRO@Yrc@ezaD0%ydHkXGHrR{7>q~~tO7ChJflwa4-xL|@#YIJejC5VT zInU4CjQ9V0+lClQY=vh^s4MadwQmk7li{54Y;Ht}gkZOIh9(vfK?3kXLoD72!lHD# zwI-Jg|IhT=Y#s|tso1PWp;|aJ2}M?Y{ETyYG<86woO_b+WVRh<9eJu#i5jxKu(s~3 z4mz+@3=aNl^xt{E2_xewFIsHJfCzEkqQ0<7e|{vT>{;WlICA|DW4c@^A*osWudRAP zJut4A^wh@}XW4*&iFq|rOUqg*x%1F+hu3U6Am;CLXMF&({;q0uEWG2w2lZtg)prt` z=5@!oRH~lpncz1yO4+)?>NkO4NEgP4U~VPmfw~CEWo`!#AeTySp3qOE#{oUW>FwHkZ3rBaFeISHfiVSB7%}M) z=10EZ1Ec&l;4 zG98m5sU!pVqojGEFh8P{2|!ReQ&hfDEH2dmTVkrS;$dN~G2v-qnxn^A2VeHqY@;P} zudZD5vHtVvB*loIDF1M7AEEvS&h0;X`u}!1vj6S-NmdbeL=r{*T2J6^VA7F`S`CDd zY|=AA6|9Tu8>ND6fQhfK4;L3vAdJPBA}d6YOyKP&ZVi%z6{lbkE|VyB*p1_julR^k zqBwjkqmFK=u&e8MfArjW-(Ei8{rWso1vt5NhUdN|zpXqK{ylJ8@}wq-nV~L4bIjtt zt$&(1FTIs+aw}{&0SO4*sa0H2h&7g}VN5uYjfed5h7eGp$2Wu*@m9WIr0kxOc}fX9eOWh zFKfV>+SD$@kESKYm{F*J90XQjr$!<~v(J%&RMuQM+6CkmnYZDGlOUdq}%)VA& zl#acS%XE2KuX~7IamK`og@C`21~*cEEc#PZM6HT*Veb_l&Ej~j0zL7p0Eo`mMu(=X zJ$v;&Lya75I4C^saKROgfi(fdP0C$GM3WyZn%mm3yEI>|S&O(u{{S<}ihUp#`X&_z zmQBma;82#`C;dR5Sx09e07FvtJLhZ{9R~|$FCdU6TDNUwTc9kNct?8e@o2MpQDrkg zN?G+aYtTjiUPA=RX5o{4RYu}6;)ET>TcgL^VpfIpluJ|lQR(_)>6k%L^FZmoK-Wm- zR5qy0P)hm8yvqOL>>Z;k4U}!s?%1~7v7K~m+gh=0c9Ip_9UC3nwr$%^I>yU6`;2kV z-uJ%y-afzA7;BC7jc-=XnpHK+Kf*tcOS>f5ab2&J&5hIOfXzs=&cz|Qmrpu6Z);`R z0%3^dioK5x?o7t~SK7u5m{dyUZ#QUPqBHYn@jETeG>VU=ieZuJ;mm^j>dZM7))cw?a`w8R z%3M0R=kdOt^W^$Kq5Z%aJ(a$(*qFpy^W}Ij$h+Jnmc9eaP(vB@{@8t zz=RQ$x4XYC#enS$fxh@;cSZ|D%7ug;0z{C8I8h{KocN-cyv3UG_nk99UNS4ki^OFkYea`q`rs zG@qdMI;4ogcd5Tr`di1JBg4I*6CFvCID_2SN5&)DZG&wXW{|c+BdQ4)G9_{YGA@A* zaf}o^hQFJCFtzt&*ua~%3NylCjLtqWTfmA-@zw;@*?d&RE3O8G&d;AVC|rZrU}jx# zC-9SF`9;CbQ(?07o8Q9E12vi)EP@tOIYKEKnO@-o!ggkC)^#L-c40iZtb4Y-cS>$I zTn~+>rn*Ts>*y*z^b3-fAlne+M-*%ecrI^rmKAVv23cB`aWD?JDJ5NIafRvRr*~~C z)99Afs`BPK!5BFT)b_^8GyH*{22}yDq;be`GnPl=vW+ITnaqzl(uYOHhXi}S!P+QZ z4SwfEPuu&z4t#?6Zaw}bvN{;|80DfxCTuOdz-}iY%AO}SBj1nx1(*F%3A-zdxU0aj z`zzw9-l?C(2H7rtBA*_)*rea>G?SnBgv#L)17oe57KFyDgzE36&tlDunHKKW$?}ta ztJc>6h<^^#x1@iTYrc}__pe0yf1OnQmoTjWaCG`#Cbdb?g5kXaXd-7;tfx?>Y-gI| zt7_K}yT5WM-2?bD-}ym*?~sZ{FgkQ9tXFSF zls=QGy?fZ=+(@M>P3Y>@O{f44yU^fP>zNzIQ0(&O$JCd_!p?2;} zI6E1j@`DxzgJvqcE@zgapQ?tophO14`=14DUZ*#@%rRi``pi0lkNgidSsHGjXK8gO{drQoNqR&tRjM4>^DtW`)fiRFO4LE=Z+nCBS~|B3gZsh`Y?-$g z@8@Z$D7C!L9l=SWoE;(+*YirPLWvBd$5Ztn3J3EaGM+#pW#@{3%yksGqy(2Bt5PVE zf*fICtPp77%}5j#0G8<=v=)LR>-a3dxja8cy3m$=MZ2#$8mbLvxE%NptMd+L?mG`v zF1cANFv17DqP^P5)AYHDQWHk*s~HFq6OaJ3h#BUqUOMkh)~!(ptZ2WP!_$TBV}!@>Ta#eQS_{ffgpfiRbyw1f)X4S z_iU`lNuTy86;%!sF3yh?$5zjW4F?6E9Ts-TnA zDyx5p1h$Z3IsHv7b*Q{5(bkPc{f`2Wfxg*Z#IvQ;W_q9|GqXGj<@abo)FyPtzI~i25&o zC!cJR%0!}lLf^L2eAfZg7Z69wp{J?D6UhXr%vvAn?%)7Ngct4Hrs@LZqD9qFHYAWy z4l=2LI?ER&$He2n`RiG&nsfLv?8$Cl)&d8a-~-N`I|&EPa@Y=v@>0Gl?jlt>AUY;H z`**5bpS#VGhdp4pKbf3iEF*>-eXg_$bqt5Dc%q0+)R50>zd^l7sN5R5Z)Ut+oz-8_ zJ`Z9HE9(=wRTD)T=%GZTEi9K5naPzlfE$|3GYGLRCLsnqLi8Sc6y&iskqA&Z$#7Ng z7Q@C0)6k;J$TlQ+VKZ5)-Ff_BNoIMm+~!@Cv1yAUI-U!R)LHc@+nSUzo$GlRb+8W< zYPG%NFfr;!(RlnvBbN~~EpT6Xj5*^Z&73tdIQ$LZu`vkfzdTKa5|JJtQ_rm4g$9LO zKtgYVdW=b<2WGM3I_j|Rd8gZ3j;)S#AT(aP^d>9wrtQS_+K>pZDX^?mN!Z>f^jP@1 zlJ;i79_MgOAJa`%S9EdVn>ip{d!k6c5%zizdIoB9Nr!n`*X#%6xP1?vHKc6*6+vKx zmEt|f^02)S_u_wlW_<`7uLQU%{wdH0iojOf_=}2=(krE<*!~kn%==#0Zz`?8v@4gP zPB=-O-W=OO3tD19%eX>PZj3YfrCt0sEjgTd#b$buAgBri#)wW14x7QcHf2Cneuizz z368r7`zpf`YltXY9|2V{stf8VCHgKXVGjv$m!hdDf0gi`(Q!(Pyg~FO28Vr#!BYP| zI)qG2?Ho=1Us9dTml}-ZOR?g5Vk)f+r=dbCN*N1=qNfG>UCLeA8pd3Ub-pRx1b3FA zEn`CIMf`2Mt3>>#3RkE19o}aMzi^C`+Z>8iIPHSdTdmjCdJBtNmd9o0^LrJc9|U9c zD~=FUnSyghk7jScMWT|SHkP(&DK$Z=n&lGm+FDTpGxfoIyKV)H6^nY~INQ#=OtIT! zyB*J=(#oHf=S)MNOncW->!c0r0H#=2QzobO&f@x&Y8sYi-)Ld;83zO$9@nPPhD}yt z{P`*fT@Z(?YAmF{1)C;o?G@dfd2$c+=Av*|;P@Yz1KnclB-Z-fJQ-=+T*g>0B7!g# zQH{dHt_%wj=wlmT&m59)TQ~xK)gB6f^EY$=1zcbGf~Q>p_PzDCHR6lndGmqPY2)&w z$Th^K%1v@KeY-5DpLr4zeJcHqB`HqX0A$e)AIm(Y(hNQk5uqovcuch0v=`DU5YC3y z-5i&?5@i$icVgS3@YrU<+aBw+WUaTr5Ya9$)S>!<@Q?5PsQIz560=q4wGE3Ycs*vK z8@ys>cpbG8Ff74#oVzfy)S@LK27V5-0h|;_~=j1TTZ9_1LrbBUHb?)F4fc)&F7hX1v160!vJc!aRI>vp*bYK=CB(Qbtw7 zDr2O^J%%#zHa7M5hGBh#8(2IBAk}zdhAk$`=QYe^0P6Bb+j5X)Grmi$ z6YH?*kx9hX>KCI04iaM_wzSVD+%EWS)@DR&nWsSBc2VIZ>C(jX((ZiV0=cp}rtTO&|GMvbmE4FpBF5Rd z6ZG=>X&>N3?ZN2^11pXEP4L?XUo`qrwxgQm4X~RCttXmZAhnhu4KDK=VkKq?@@Q_Z za`*xyHrsAEsR zV(7)2+|h)%EHHLD3>Qg{>G|ns_%5g5aSzA#z91R zMDKNuIt@|t?PkPsjCxUy&fu^At*yUYdBV!R_KOyVb?DO&z$GLJh9~b|3ELsysL7U6 zp24`RH+;%C(!bWHtX&*bF!l-jEXsR_|K~XL+9c+$`<11IzZ4>se?JZh1Ds60y#7sW zoh+O!Tuqd}w)1VxzL>W?;A=$xf1Os={m;|NbvBxm+JC@H^Fj$J=?t2XqL|2KWl$3+ zz$K+#_-KW(t)MEg6zBSF8XqU$IUhHj+&VwsZqd7) ztjz$#CZrccfmFdi_1$#&wl~A*RisBaBy~)w|txu1QrvR1?)2mb&m2N$C(5MS%hSX)VJnb@ZGXB5^%(<#1L@ zL^>fBd+dEe`&hxXM<0A9tviIs^BDkByJdc~mtTYr!%F7Q1XnK2$%h$Ob30*hSP$Bt zDd#w{2Z%x^Wpv8!)hm>6u01mY!xmPgwZ#Q0148)SxJc3Udt!-&}eRO^LN ze26pQB!Jhg&Z>#FD>`C`sU44><=v>O>tJdLs!HPpV#AM32^J@Za-9J(CQjKxpzXao zQfRkWP%g9P8XV21MmoHfx{DICLSc*t4qVeQL9t}&Pz0rM}YTba@XsD=XMW@FxFM{QYQJHvM(JsUSa3mcTUl9^qcVA zBveO--fqw%{#QGR1vy;x88+qMcgzmcYc#8U`CPPt6bl?uj%w_`b~9JliftnOa|ziW z|6(q&STs_*0{KNa(Z79@{`X&JY1^+;Xa69b|Dd7D&H!hVf6&hh4NZ5v0pt&DEsMpo zMr0ak4U%PP5+e(ja@sKj)2IONU+B`cVR&53WbXAm5=K>~>@0Qh7kK*=iU^KaC~-ir zYFQA7@!SSrZyYEp95i%GCj*1WgtDId*icG=rKu~O#ZtEB2^+&4+s_Tv1;2OIjh~pG zcfHczxNp>;OeocnVoL-HyKU!i!v0vWF_jJs&O1zm%4%40S7_FVNX1;R4h^c1u9V@f z`YzP6l>w>%a#*jk(Y82xQ@`@L(*zD&H>NY`iH(iyEU5R$qwTKC5jm4>BikQGHp^)u z-RQ`UCa70hJaYQeA=HtU1;fyxkcB2oY&q&->r-G9pis)t$`508$?eDDueFdW=n5hJ z08lH$dKN$y#OEE@k{#|<%GYY=_c~fHfC@pD54KSP9{Ek@T47ez$;m$}iwR}3?)hbkwS$@p2iVH0IM$lB*XYA+#}-re|UNzCE)SOYwy z=Y!fkG4&I%3J(_H#UsV#SjHulRIVcpJ`utDTY{k&6?#fzt~@Om=L(vs6cxAJxkIWI z@H7)f2h%9!jl@C!lm+X4uu;TT6o0pd7 zteFQ(ND@djf#o2kTkjcgT=dHs7ukmP0&l8{f;o3JuHGd2Op*?p7?Ct=jA*tIg{MZk z$2Lsc0e8Tdcwrjx|_Ok?9uB3Il|^2FF%X#ck}WoIvrzQXN%kT$9NI{79Wm~gZ3`8I+O`)`n30feZ( zDO-fl6IG3c^8S;Y_M-)+^CmM0tT^g0?H#>H8!oC8W%oU!~3|DJ?)~LT9*&GAQG13zOGq6gs*={cu|(V7{R$y@{-iV*9q@AD(#Ktb}J&3&k|5Djs$)9WM7!6#EaJ_ilvbfUvyh8c?-{n zfuFrC0u6}UJZ7aj@(cNG_(CKgjQQTA-UK@-MVmick zot}6F%@jhq(*}!rVFp5d6?dg|G}M*moyLriI!PQDI;E1L1eOa6>F9E6&mdLD>^0jJ z09l?1PptuV65gm=)VYiv<5?*<+MH~*G|$~9Z3XEy@B1-M(}o&*Fr9Sv6NYAP#`h{p zbwbUE3xeJ;vD}QMqECN)!yvDHRwb7c1s6IRmW!094`?Fm!l~45w)0X`Hg+6Y0-xf# zSMemBdE)Q=e^58HR{kWrL5-H0X6pDu%o{0=#!KxGp0A;6{N5kI+EoY_eTE%2q|rwm zekNeLY-R?htk!YP2|@dbd8TWG4#G)=bXlE{^ZTb^Q$}Er zz)Fp)ul24tBtQFIegdI37`K$VR3tVdi<(fIsu{#QMx=$&CK9M8oN%3Mk;>ZPd-;Q- zn|sSKSnc-S0yrw#TlA$+p{J~u=u98s>IoL@cNLOxH=+1m?;t1bR$vR=M$US&Z8DO3 z_&zhQuId1$wVNsS=X?&s(ecIi#00o{kuPs6kpYkL$jMyGW8U7mlCVaZeEL=HsIxqm zFRLxWin8B>!Dc#9Z#t0RNQiR-@5J+=;tC7|1D*~rxcwHa5iIVD@99cCFE@BukUC-S z^iJdt?dwU)kH2VY9?|zVShMbZctzFRz5Q4tiXa^>@U%jDYq}$rSyc#p2wXr}mc0qq z^lT>$y)N(Qg0dwmEwTopneoU(y)>Mj+f{iHM0o|>ZtCg-itPj4addYz??aE)Rp&hk z_SI)%XeSf=SjZq18h!Cc>Xy&EynnxdHQ){(x@g|ZA%`3LU^KzX02c5N;F#tEk1)7v z(|V9tO3>?^X|kQ*rRBf4>mWW2$-Lx})|M7z125&VHcxsCqB!<$l1F$zCrJ+nm0f3Z z%Hq^=SKpHyV2@Y*Cu2x>fXC0SscnR*($zEB{KOniJcpn@e`PMH*_Q6*0Z^8RNCEvZ z+UU9!927p9YZ&g=bnUvQUZcdisyn;-4;ACXOe-Xor9K8Qbp{ldE17+G@VQT+9ZJQ*9dZoXfU2ue|mMhrrZk2R7&~YjFW4`BTq45UwVc6JORKU)wBCTanITh0GD}s$`C5pb(9{b9 znwee6j%?-UV)_7opOioCf5@C?@w^@g& z&68+oMmV;5JW@TT63&CSDrfYL2$L)pVseDtAwPwleEM3F^-Ufn3PpfxFmx6o zQ`Wq9x#d$e`VKn5LOXNsrqhGao7~|s(u~drPrZ+;aP!C%z4NskZstCbAibD}O%8Ij zb~C(taxco~WzJLxhL1T}3ctXMbV6}_z=IZN9L0|SxLSe`$X`<)BhM`$1&&)e_}fCh z=idVL<+u6Vn{&ksP*ZLlMo$fC`dtzF_?~L?4Rril2G4%v5^7sUa^&8aMtMX&mtapl zD(dW|cisM3fqMaB`8?QbkyiUl2g>hMB5EoS&IB8TdoC~)b$nT=`%GgU`k-)+8}`)F*~I~DXMaTP%kZftx11~?iALs5J+&Rom#p%Y z>dH}-euH4u=_V3hc6^*2WMtL!9%yRTJ93p}@aV0zdY*?xchFI>m+UivV=;aMFp0P~ zwB8P)wvV6D-GL?6hJ#g7Hy7=2i^&Od#S=j!;Rc_yjO!*4aN7{vqzg2t-R|Dav%_NDk z`H_FVlSi==(~f-#65VmQ{EE92x<03lwo5p)s=ZJ^L7PlS>132Whr zR6v~t(#I+(`usYLCoO;Rt8j&b^5g_xgs*98Gp|N}b>-`HtVm)MscD)71y?(K6DRCZV26RsHPHKk)EKKZA%C99t3$t^B0-k5@?E>A-YMbFe?>ms?J?_guHHNU(;id*>xH zTrtam+Aq?n@-y@uY@A?hy?1qX^eLu_RaH4Ave?A8NapgQF=C%XI7wlcCf4<6BRo_% zBXxxc*A6-3CruF?3i8HOdbc%>N=-iiOF+9HX|ht6SCkz;A^am&qi_I&qk1B(x<=(m z>QG)nswCOLl_1{SZ@_eE#m^qb6#6DoMsB*)`17ui+XvF%(}|J4G$z2G*;E!1ERnAH z@q%=#uV6kBddqy4=g>!VTV)9*1=i{wJ}Ep!I*?)uJdA(LwE?(!?;}_u=^M2NShWC_ z*7l4aBJ=!QVU2-iehgb`$vOI8zkm{W%QO~?xOD;NgI;Iqa3#^$^U5D&McReLe&qs# zR<^@QpR4#W~Laz+QBsPt@3L#KF`Yr8}jgHe;5(cfpQ=;Zjtbt;c%y^#-m=hqOT z;KAYakW+$w0&F}>K10&SiPcD9SrDOuczj@U#W})5jGU-_htU`U6Q%wdy((%?J}y+$ z=$4jw1N nJo)qTxG{D(`3*#8tY|67hJRF;)r6F|#I`Ar6I0aafRa=kr-Z0I^}9xf^u;G5iEQCbpv3b#S#%H|HYHsQaHK$! zU#3Fpz8*^pK%RRmX<_09eIVziB0jOgPgFnI-*QcwEBtBiO#v!>{W1cLNXyw3D9M|A z*oGy(u8BkDA1c;MsXmpK^-~pl=We^RYnhZ4bz*)Q)C2G+E3tgx9PzU0T>c|1ilS!T zyE=bz`=wskDiOi!@!l?Y))#%{FM`}7r~X)i1)1*c6_2Q!_1{)fp%cS|YF+Q-CB%d< z=zYus`Vt@Mx*a7V)=mpLS$-5viaKgNB=+zN657qy0qR94!cTtX-Z%KBCg4OKw7b=t zr=`7q5Ox=lJ%!G5WIyNQC1xpqYU0{!I$hyrk!6%De$gp<_*Gc?ES(OwY8U^)Kjgc{ zSlhpXDb|;{+y9`u{EuMz54rlky2~p6xX2>MV6BZ&k`$q%q7v(xYps2wr9e8^4<;CB zc)eAT~B^rjzO6<4BDDH;il6 zFsM8jL+agQ;zazW(uiQjM%fPf2N~_p{cy29XP11_lQFpt`t#9nlk}>fv((FZt-dBa zuMIc4HmPHW04n0TTG9ug9;&OV9euL$Ib|+M7}}L~z4e%%%b|r~6OQj(S2d7XfYn#xp8;KQ55UYu#gY*De5j6Cc z#R%?rqwpy7I1(kpU7B*Pq=etXeYUn04jg%ZPjYqQNa$==yTG=6KX+=;i2Xg+kjV2T*Gc!(ef z`Q4fR*TA=M5-}z+s%YO+!K{k}S**ic&>o4_Tmv$EQTOp7F6TXPCj-UTXy?OQ=%*y62Qajk{rXbR%jMCOFMiVE3KekQa4xR}B%=iPtd8BXo~q$OX_ zSp910{Ew;m|GATsq_XiJ3w@s(jrj^NDtr(Dp!`Ve!Oq?|EJ9=vY2>IfrV{rT%(jiY zi}W@jA2iqd=?q>s;3%?@oi7~Ndo3Ge-2!zX58j(w&zVlPuXm3rcHb7O0RsM|!Ys(b zh(=*&Aywo3vuJoWZnU!u2_4bNkDTc&&bCYc%T zM~~xYxS#3KXFzQ@OXdc%9QDOxqiTd_> zT;(DX9{5dIuC4pO_xy+3{Ov)1I7j!Z)6&nHUvTRP>VU5dm#849icG)cvl0QOPkCIzG^lOp4#UcNr`VhBp(Ha%8@KPlvT*5u!v_$b#b~%sn3K{mu zaxeD%Q~{;Lw03ZAq(Pc-IVj>n*h3l2{sqioCMGatQY0kx zi`1(WWDQ=;gmLSGptEQ%UFC)th@|71<8eiRtX&Mx@#1q#nMF_BMfQdS>!!Qkx2o}= zuqRi?`UOX5P3fP%M+71Q$ctH4Av}bXED#fQ`KR4!b~60nsAv^*M7c-x`|~B}XIuq% zlqIJOf>WvlhQ@Uw$du|14)tZ?; zPNZ|xZSwp1y+d4sut8E4*l2JWR|~o0A9vD-?zC-w zDc@=wE1YKb*OMSi_Kx}&w;#h3>sHp|8^hnA3w?-WK)X?@Z2dgV7`9Cupf-B2RE4x^ zwlw+~!V9C^tyb`J;m2}ksD`w}G9`yu(^--{SQ+wt^Fu4Li~Fft!3QO`upSkAU?o;# z(1Q%GUVWbbkTK-M=T+ULkk3s6Dc9`G4CO6|=&-S&D+rbJQ$`Y-xL~ol;kc(l)VbU>{&>bV+*?ua;$bnDc29RW+Ig16)Vf6=L|fMR_P2b7>6}0 zdlB#-gj|j*C~M=F^2=K*k~=tl6YM3SXXi&K-`EvEXnWz&4D-^hQRBJI3gKKDj^6|> z*WhHSim1qAffNt60Mve9lfw^+&0bx-AM0%j>QP3%W=S@(l=(nrJ678mRQ(#+sI@d{ zdb#5fo#T;hK7xJ=M58wZf|?DHwD%!OZ3JrTGV5#{cfQwuiMvz%!CQ}CubJ7`z?@rSF<+KHNV2goc)a6hP0oHB@3LLKSH2w{um&J*z1Ka2 zLIR>lvOvh>Oxe%?3A@v<_T|}${zf_&@C~^FCo#jB(W9VLO?DX{)n(BQ0(V0`mI|9Y z#U3WwxixJkU_NTvA>5q(A@r2dnEXJp#6B=pww$XGU}~1~c``UKqQb=^*2P|4Dq*_! zhY^i61Sy%T5$Td0O6^C>h(xVvT!}Y##WeT8+s+Uuz=7)~V$>!zU;%d>H)rm*6^IrsCma%|cifwDLk_ z!^W2voQ)D;I$=v2E>iSaBw!d7aD+|LWl2iD!cBw`Q5p1~fk_xGiPi8e^mY&#viTAk zmaKL8m;JQ4bY(n6uBZt02z#noMMxTfF-RzjKre-c+@B)#J3pN-Zv7F}JtAwNk3j?OkpVCL6W1)Q$FLAj zGI!tX;g`O{%pt=0|q54Jyj##w*4e*|_;Us2Tn?!#^R(>u}|FAw1G_ z#wQsagnj9$TAC`2B_XgB$wNq~Sxgl?#0+QWWcB{G`c6~&SosbtRt}Tukw`TQ!oG1= zYyL(y<;Wh+H24>=E}Gs=Hs2%fg;&Qdvr74{E!R?Bd zIRQ?{{xkLJ_44P@y3^#(Be%(pk%$liKbUUo76wSoVfJmt9iTKL3z{uW6L&?jYg>EY zsx{kRiW@q%<$VZvbS(TKKTO4{Ad6l^IeY(F^3}=mX9|FZmQ`~RErNxlBPl3ast}W$T4V?SW=6kIGn@-^`qJv| zZXwhK4Kl1a4E}nLI`rdOi?^pd6;LZ-|8G&INHgOeC5q{_#s+SXb0r(;5ryHFsoTJD zx$VtNDh=-Tx3t!NTlk=hgAaSM)#U}e>_-Ex(|JoX*hWmBPPdTIa-2(BIOUJ|Iddy| zwY*J%z%W$}*;uSoB!BIJB6N6UhQUIQE_yz_qzI>J^KBi}BY>=s6i!&Tc@qiz!=i?7 zxiX$U`wY+pL|g$eMs`>($`tgd_(wYg79#sL4Fo+aAXig?OQz2#X0Qak(8U8^&8==C z#-0^IygzQfJG4SWwS5vko2aaOJn*kM+f1-)aG{T43VJAgxdP(fJ4&U{XR90*#a)G8+clOwdF?hJ?D) zmxu>0>M|g_QRHe_7G|q6o`C>9x4xd$Gl7lAuR~+FtNid=%DRsnf}YI*yOToWO%xnP zY*1G5yDnTGv{{xg5FhWU65q3-|-(+-rJ2WCeSJn(7Az>ej4Jp9+l-GyZ_| zJ8}>iA4g|}q1AhEEv#uWR&$g&Uyht?fVU(qk(j?^D`))s>oG08pow!f>P1u71P%oL2)UC4GeS87&G?{)NE;D=my1Q9{~;y zJULE=bG6jXE28Y11YmoZoo945`MM*`v%5b=_02*0cwzDve#3(4M}NPt`)?SCa|7*q z-94ks(R6WH-l9fE4m4}10WSu&O`|;ZCIT%vL$_pbABY!}s33@~gIvZ0H4co|=_-T$ zF#lC7r`89_+RL9wYN=E3YwR?2{$^ki(KKd>smX(Wh*^VmQh|Ob5$n_%N{!{9xP~LJO0^=V?BK8AbCEFBhDd$^yih$>U z(o{RReCU{#zHSEavFNdc8Yt<%N9pd1flD{ZVSWQu*ea1t#$J5f6*6;tCx=&;EIN^S}*3s%=M#)`~=nz!&Q0&{EP|9nzWyS<#!QxP;!E8&3D}?QKh^ zqGum|+;xu9QE=F#fe2ws5+y1Igr&l`fLyLKry=1}(W+2W`waeOR`ZXlW1B{|;4sE3 zn^ZVlR11hiV~p<~TaSen8I~ay#7Ql=-_|U@$8yjZsZ=Vi+^`JV2+kn+oiSUi%omO_+7}saXnJ9 z5ETilbag(g#jZPopCgJu+n@(i7g}3EK2@N zd64$77H5a`i%b%a^iRjMaprwzWz(`=7E6QY)o)gek7H)yZ-BLw^6FAoHwTj9nJtWc ztKaytMlWGLg29W{?gr|rx&snb@XyvR_}x3fmC>d=-nQp5ab3*whTw}DfUcKlMDDx` z-%?ek^*|Kqooy#>2lfklZ|jN4X$&n6f)RNNPl(+0S>t(8xSeOGj~X0CGRrWmm(WXT z))DDW_t&y$D#2`9<-+JT0x1==26*gpWPV~IF=rePVF%e-I&y$@5eo~A+>yZ&z6&7> z*INESfBHGNegTWga&d@;n;FSCGyW?}e_Qw#GTLHo*fWxuuG@I~5VA!A1pOdRTiPA~ z^AGe(yo=9bwLJD}@oDf$d+34~=(vIuPtOKiP}obDc|?@hY}J*@V|UynBeAkYa?S{@ z_f$U=K+>deTAi&=a*xv>Ruyw$UsTWY=Yn=xjf;s)6NQu>_niQ_idmzIwuL`Scf)f= zyzK?D5a5)^D@H&qN%F6Zd0JeXX*Knbe~VLe^gi|?JK67&mB4jrapV-$`hCQT;C{%T z*pjxB+Y|~LD9bmMN%Iq}S$F$x1yWU7@GcR91V8h;!O2I5MN_rq*gRx(k8T!1WSDTp zr9eJO4$~H94aG^6k5p8k=kFJ>4lnY0q_Bsa$@vTRW6uY?slH|Qt)Yu6Yun&pfJ zBi!h;6x?FDs&79#PT*HSCEUsKws#s%TFy*=2PAfb`>gEPBn+D-WdfXA?MkB=<8kb_ z1+4D11mdHG0EcAyg4dneLtfJ8)RyHQl@6hWJNe(d_EjyCHf7%Xsd)S4A-4COz{G@% z5xQ!P>AS@H@;4Ws)N91)3A6PleMe2<& z!(zv#%Uc?N`(Xmm)OJPYt)BM`nRjoWA&P0Yxl@c9Y02zlPH1J5l$nhPrMwu=atkz4 z)a-1+OEL;d@ctx=s<<+3Sv1VYy0RYmiji|#hy$66#`5;u~BkH4^$EGZ-Y4xyZ=%3KuaeLYKAUr$xMtIh_5mga> zPz<#G0mQ7IxEw-yO}BueN}RaFlg$RwCDB)vLF$wDu%qZyLYsPKdcbHD23$qn9i#JFqIo#OK?u7db2-$GatzO!On87%}Br};~#}n zziVB;qf_4(K$u>Qyz$ln_kBGS!CD-t4Y}9oxL@7@Sx*?NOAzdeINUD>Hl#*V%pfA; zSA`==YatS*G*crJ3`3ll4)vKss&)UtY#7ZxiVoG%9(4<%`WWcjX2jV(^g7Yhj+h5J z$5=?S=tuCyEt74^6jo@6y|@~N>&cVfFNtaRl=)Gm!vR;Bc$3-;ySCI$%kdmjQ|si` z{$q_YCe6vjy6re9jGN|`43D``)1PODtz0)vhV4XV36nVpOnMx2uM%qZ<3TtcI%>BQ zf0(J`{JqPPJxw>k#&nIvoZ5e9Sno)B2r+E0G} z@&M|zf4E0Q$O*NBR2I;?i7N} z@2^Su#`%qeX}m3cbSojiLk#84kvW1fICNPS`OyT0SpUoA0(s^2m~J<^eKE!dhJx_N zG_T}0&(<*an>oF=@?6?55g&IxSgY3?7|@pmDRE6gJyJNPH6un~%0hZ@?h=hI6O$b^ z)29#<4$E)cE-5IFbRpk9JVrw$$966UDyw;Iym4OY4Fc!&s1ZH4BJ1-$9<)Zt1c)N- zU^&9hsk6z?3%<9kGKHW|6~k;&cghtWz`oz`_YjVuvy;B;T67=L2c6=8`7WyTBv*QH zNv*bo1#KOk{O&)@&pkd*?v+kcJ8tM>AGx$~WMhH{L40_N=bkrVg+^p!H)IqXCQf2_ z0fPig=8CEo>p4vE(nc^DKbZ|9_Xo}$i4zJ`jVh95; z5%aNP3@``=EJ=Vt9U`y+$YtX;%OPzgZ_3+;+mh{p#W&y4-%%Bf`LhOy-*kB0qnB^m z_nBTz_b?-`F$*ymByshU>D)za2g`0j^ioo;A#QeL@x3@|+_!=YXA5f6Xg(Ack&WOg zJ<2i|Fd6OmyH!@YSMVxb;=M)ZDhBt)4`5T*>cUXWPG#%@$&*>K&u3#|`fm2mj*FKVf?du{xZ}WKWETTFhq6_fO$PS5(ItF=3~pFp~*j z!ys1<4EL1)#{`mz@gW|t-FpPkd%pK)n_Rb)F;z7cQ6dym_>YI3&e!=!m006oS3Mjq{q ze%hNzW=G0jpfl2K(x`CDuZCsJV*hm9T~%5n7R_g}VFpk`G((D^MWVMAmRp--T{`P; zwMgD<;e`fm`g3|fPns|6qnd{|FCHY*YAguXH(?%sx%4+Gu|Y)_8mk4EljxmP+MP`* z`SUbI{TCIN2OV+$y#g->Jqv#$wL;}4xJmah#$0`v^ughM_XjTA$B}ux)JZuY5-GW4 zKy440I+w=ZtE-_i+0xImq}vyzD68?8;94-5L~_O6Ty>X3itdA-x?6P(c4jkr+f!H( zUDeqiG>3bn^Sf8(`_YwqPeJ9&-@OCQZm4X{FfRMeBtN4E9Ca@;GVpU*L>lVb;@=PH zTQvTr?^jKyCKh&ZVOI*<y%T*Aw(XCPrFC=39*y$A`FSzxBiQ#W+uW10d8&gYp4{teh;^p@anft+z$5!Hv&@h0X-@xJG>hbTCxjDwMiWK@1b%8wYL6BrV zT41m}tX8g-`P@vj4T!Mlk8F0S!MA`^J=SCy9-jdwDe^hVDa`WwyI^H@ryt=F5y6>b zT8&iI6&j8edAfX^ycgWbnMZQ26Q~`LmdEScKC8|~$Jgyw(>18NAQ$9AwCRmri!96L zp^)b0P2CR-9S%cG$#rU}MXnx21T#031o>2VrDs@sa-FpjfvgLPW>Q&LHUoNOtmkt# zoDZ=5OGp{^vO~=p29^`aXd8K?(+f-bW`N$U;-o;%f?RcR!k02Nod2h^^8ly%Z67#E zC3|IOuj~^YBO=Fklo@3mvd6I{Z*&FZ>iq* zxh|JuJoo2$p8MJ3zO@dQ;%1#~Mrm48 zB0053{1bDi_a@jo<4!@!`w4}B(&Qb`~IeSBh zu+_yIYl2Wgk+?x4pCmAM>x_SqBPUj#c`C`k>_fp@qPlAAwD$!zOxRkL7;=|nu(#ut zyF^;&hm-D_;ji{d6rOloACu5*NkF4IC3@rifMG(|^Skv$H&^YnYL*rpw=UCi;JOuz zN*NX(7wZXS4tF@6PIWAs%*j!$RoL*3sh)}iry%thDvN5AUM888q_(>|Tzt|Yea3AyMYBgm$H_`F^v2%)bux)3s znFIEBDK;-JS5SH|;1?afJb<*=c5puu=w%tv#ihn*R!^Hd$KWAp4$#`joJ*)$kNtZ z2Al6h>Z>(u?3tmzA4^d+jLKx{97!Pb4;CX&u;M||**7zXI7hO6nrdMx*Xa=|-`#1^ zBQ?Ha&7cd7hN=%y4yUp?zl8~Lo;%mQrDe8!ce-W_K94FFMN*g(w8q-_K5S+c0{o29X&PzpV;UJE^!xnFc%b@>kvW4m#xiOj-L*DadC&2N#0Us z;<-(m1WB7$=j6hjcPC6JB)D3T2#IC`ibu#yi!uK7W2!j|Z>~RaJ*&XXy#ytIk2DIp z5?Qd^s90_?ILjU#>ZWk5HXts}grg_!Gmgm!d?eLGR7xEP zvTCrslV~94ym5_i<5oqy(@@?wN}lIdtiY8=?|Ng!XeYnly`@9wCGx2S$3x|0x8T2h zz7A85Vb2>s44rKpI_4Y7_Pnd2^mYj2%^jM|Du>u4`^Psda^JIP%*DK6bo`Vf&f{!% zDTYCwF5Nhi=)QhU2$@eQv&ZzxsX+Hl+gP6kW|e!n9IU2>Vh~cioI{>4WvR}t*4Hpz z%5z?HjLGoka}Q3AbX9AkY|Yjf^M(>@tBAI9JO5pDCQu0R3Nns>)LC#vB2p96C*?K? zvX$un$sBDx$1=+NNj*@Oa@u*b@O*XBr_sg@8sCUq-|LK!MUmC)epklrv}5O_^<{NP zX16|c$9Wtbks3y7geI^tF5oRZJu;v zwkW8j+8Ccxo9stEDOT_Go&j%$KCgVO7pm+^%PKEPBZqbMw%s@732XS{cX+wCSjH1s z5)bc=g**<^NNsroY` z?}fHHlgu^B?2r{^^gQ&j zbF~T((>|Yg&C5WKL8DCnl1}Z3!YHFW2S1|;Xr0`Uz-;=FxEwYc4QpeAtnm7^f~uzX zl;xA!?>MLR?tL80Iudm;mi{!ewL91KhG7Hsa-XepKi<2mc6%zf0GwtbfJ1Zf-<@Xu z#|XWDzv|04t)&9Id!UxAAkN{t5qC%%8-WV3i;3duS19%m2||Y{!3pR1=g|zQYAMqc zff)_2nj-O4wfxy;UNM?|Uieo!^J$A*uDe>@V(NKH;KS;Y_dtE8${p>RdcrW;=2*fj4~d?OG0l-(g?ik}vz} z)5-wDppVts>K-=|@{=!53?=8)Jw#RGpS_FWpbwtn}{v!JEJ$q-sr7F6&OPBuI# zuVNFMPte79XgEu!P&qRq8u4J>r%$l-IQ00Lin90(_KtC)aR_de zxN=pY2<1b29_^AG2WJIGmmX4rv3$!`l15{e(H!1^+x9voZ6;882YAE12q7+lgy+>) zj|s0CyzI9=Mo!R}&LXB`&DYpZ7c?0r(&KNV+~TULd0y^e;G{KVR4nL0KvU9mr8&$^ zxrM-9P8zE`J?aZ(iB~Rz<{vvnk2HaZU#K$aVFfYnbAXVUOLU#As5JvS%+26 zi$sNuPY}dLGUS$0g&;oBqhzv2dY`l3@6Na403M!Sh${B|7(y|_cONa;6BrtUe@ZzV z7SThtHT8k?Rwc)(Z}@BP#H@JJHz&GR&M=E@P9KJ89yQKmRh&I~%vbL1L-K3E>7>CH z)Y!=jXVb1iPrAoAZZ3}3wU*5~nrV!ZjL5zqJ<@NwjHCZC>68Cc<{&E_#S;E*jOdjtg?uKN|l`P8sjz&Qf7a^z9 z;{3-8T+H4y99_zc;JYIvs!sk$G}` z??mt*Mm9Z@glCZb!X?!xXD-21sFDPEpZOK{sbQseQ$%6~b;n+*z0hRoR}0Pe>B|#t z$XrVcXv8M|q*Z8MY&r9J0A=d^1bHpjrUXu)qEj~$%%=gZp`^~%O*lzxUquG^p6;n; z^(3HL+hx4gRP?4N*b2p9!^|2~rcw3!9nQj$vmZusbXYz_x^AVc`3qBFm(jS9ueU5h z^AnNnbswfQ2Jq=W=T+p-V|nQco@bOAH$pLQZ+BKH8E$iM>IDz z3|wc?QP`yI=X5YTlp8h}%p6{Deq?S0QD$Ug>ih1SdPZg237Rl{S~=Ha4~-ckMoIWMn+X@@`V6 z#HHZj>MQbt$Qqp*9T(cjc^lxZ7UO(>PwzF-qEr(wo`vaulxdall|KP`7p4gd`23&Jy=#sAes*0diLB(U$Nx46VQvP)8idSs8^zaV91xw*O-JMH=)FoJshRob|_)O)ojtfP))WHCr(;*2;VMQ75^ zfN@a^f#o<|*9X;3IcGodLUz-3i~FAu+zI4c5h+nW^h_!^)b*B_xw-l4O$TB(ixaqW ziMoa%i=BeS<-F45kMO;Tw|FWa`G2c!SuOA3CbowPhF6csf1|&qqugUrj;UgGHm| z;j^yoH?MZhR;AYOW_XW2Lg2j%%ejL)B@*bUMD`g<#Z${1+fa57r7X82 zcqY-cfPnK%Y^3@szRner zt)bBToYCph6Jv*W+&t?&9FG4(Iu2w46 z4B#AcFy_^J@f*6<{>CN}Sj969*DYV*e7<61U>GoN{tz!Do90+jApFueVY_IW(MQF; zl?4yA_(MvMwN&pWKVyg{3uU_+y6RMdot2vu%mC?st=N0pf-~JZXE?3JFf)j<{1xsU z`2ephz)#HzsWEP!inHm2hI(V(~@W zY7gGU-lO52cHD&SY)>QHgy$=>^X%u0TQZfCizro!*weMyvZC=;MWOawdAx~`3C*W` z%^#^$uRP;gyqEE0<(i8xcQY$oc+6mY#z{-XFxsO1(cN8Y)>p;^q9|5bk`Z*p|c!?(rErw#y;yT(%@c7trQBv6cj)$3>pI z>tz+;IB?D=aQV=s(n)o63*yn8dX1m7#Z4G{%fF@K2o5n3jxR~mU?nzMi#;}8e#(>{ zy{Z4!AI)jZ8TY;nq1aq}tq;~=zzoTv)er06oeX3;9{uP{LWR*2%9cmE%S^`~!BW>X zn3PZFTf3g*dG68~^1*q@#^Ge(_8puPEFLD8OS|0b2a{5e=N4S%;~f3tC>F6UxK#v9 z)N-#Mv8=ePCh1KsUKD1A8jF_%$MPf|_yCN9oy%*@um6D{w*2|4GY zb}gafrSC+f=b*W{)!a!fqwZ9)K>fk=i4qf!4M?0v{CMNTo2A9}mQzV=%3UT&i{3{W z>ulG#M!K7%jPf6Mjff9BMslgQq3zIogY);Cv3v;&b#;^=sh#(Bn%W)H*bHNaLwdpq z85%fUTUJJNjYO_426T2TBj0D{6t zw&S_HZ|C?pI_2q(9Fas&@uJs6nVX;P*5K#6p|#)_(8PM-{L(;2wl`ma{ZAd5gA)?y z>0GSLoK<*FwW+G8@-M3vcffg7I(qm7lzF)n`Q9iCvp*mn7=|CjlpG{x z&r0n}XLWZ!>=lynUr7D`6n`7a_ZgT< zm!i;&?Fb0Q2QmqmCHfZ7ex=_tU~(7b)L?RIvPyEAU=gLIZ-VTAA~WR00yKyTXg^(G zqWLZJs!FnQYMOH3*fN&Tn(IKMLf{Ki?pRo8zZJ6YVyj)y0^)-sR}2-)%mI(Aw2AgT zbbp1T{qB(OSNJd0cVBH^tI>HR(q+#*lmi@LWe*rZz&M2h1L_=50uZ1e*n#E*`6?aw zj`ka&JpceRGe@}Ey1)Q~O}0qHRg4K_u>4e1arvJ7Q9!=t5AuzG`n=a-f0}{+lnCE#zu$`oVn44eS&T?N*wz~t~E&oQDBrB_MSg z_yVrQehWbD0xHX|v-hpselAu;O7s;P*!uAT`dr~}Lie=tknaGoiU?;*8Cwgala-65 zosOB4mATbdXJFujzgA4?UkCKE093A1KM?W&Pw>A?IACqg1z~IZYkdP70EeCfjii(n z3k%ax?4|rY(87N&_vhsyVK1zp@uils|B%`(V4e3%sj5f|i(eIhiSg-fHK1Pb0-mS^ zeh?WA7#{hhNci5e;?n*iVy|)iJiR>|8{TN3!=VBC2dN)~^ISSW_(g<^rHr$)nVrdA z39BMa5wl5q+5F@)4b%5-> zA^-P20l_e^S2PTa&HE2wf3jf)#)2ITVXzndeuMpPo8}kphQKhegB%QO+yBpDpgkcl z1nlPp14#+^bIA7__h16pMFECzKJ3p4`;Rf$gnr%{!5#oG42AH&X8hV8061%4W91ku z`OW_hyI+uBOqYXkVC&BqoKWmv;|{O|4d#Nay<)gkxBr^^N48(VDF7Sj#H1i3>9138 zkhxAU7;M)I18&d!Yw!V9zQA0tp(G4<8U5GX{YoYCQ?p56FxcD-2FwO5fqyx@__=$L zeK6Sg3>XQv)qz1?zW-k$_j`-)tf+yRU_%fXrenc>$^70d1Q-W?T#vy;6#Y-Q-<2)+ z5iTl6MA7j9m&oBhRXTKr*$3gec z3E;zX457RGZwUvD$l&8e42Qb^cbq>zYy@ive8`2N9vk=#6+AQlZZ7qk=?(ap1q0n0 z{B9Fte-{Gi-Tvax1)M+d1}Fyg@9X~sh1m|hsDcZuYOnxriBPN;z)q3<=-yBN2iM6V A?*IS* diff --git a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.properties b/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.properties deleted file mode 100644 index 5366408e6..000000000 --- a/headless-services/spring-boot-language-server/src/test/resources/test-projects/boot-sql/.mvn/wrapper/maven-wrapper.properties +++ /dev/null @@ -1,18 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one -# or more contributor license agreements. See the NOTICE file -# distributed with this work for additional information -# regarding copyright ownership. The ASF licenses this file -# to you under the Apache License, Version 2.0 (the -# "License"); you may not use this file except in compliance -# with the License. You may obtain a copy of the License at -# -# https://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, -# software distributed under the License is distributed on an -# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -# KIND, either express or implied. See the License for the -# specific language governing permissions and limitations -# under the License. -distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.3/apache-maven-3.9.3-bin.zip -wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar